From: Seoyeon Kim Date: Fri, 23 Jun 2023 07:23:17 +0000 (+0900) Subject: Refactor dali-csharp-binder source files X-Git-Tag: dali_2.2.37~1 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F86%2F294686%2F6;p=platform%2Fcore%2Fuifw%2Fdali-csharp-binder.git Refactor dali-csharp-binder source files - Distribute each file according to dali modules : dali-core / dali-adaptor / dali-toolkit / dali-scene3d dali-extension / widget-viewer-dali / common - dali-wrap is separated into dali-core-wrap, dali-adaptor-wrap, and dali-toolkit-wrap. Change-Id: Ie0b9c14dce576189e41d5d3907b0eaaf05de6540 Signed-off-by: Seoyeon Kim --- diff --git a/dali-csharp-binder/common/DaliWrapper.cpp b/dali-csharp-binder/common/DaliWrapper.cpp new file mode 100644 index 00000000..562ca053 --- /dev/null +++ b/dali-csharp-binder/common/DaliWrapper.cpp @@ -0,0 +1,54 @@ +/* + * 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. + * + */ + +// DaliWrapper.cpp : Defines the entry point for the DLL application. +// + +#include "stdafx.h" +#include "DaliWrapper.h" + +BOOL APIENTRY DllMain( HANDLE hModule, + DWORD ul_reason_for_call, + LPVOID lpReserved + ) +{ + switch (ul_reason_for_call) + { + case DLL_PROCESS_ATTACH: + case DLL_THREAD_ATTACH: + case DLL_THREAD_DETACH: + case DLL_PROCESS_DETACH: + break; + } + return TRUE; +} + +// This is an example of an exported variable +DALIWRAPPER_API int nDaliWrapper=0; + +// This is an example of an exported function. +DALIWRAPPER_API int fnDaliWrapper(void) +{ + return 18; +} + +// This is the constructor of a class that has been exported. +// see DaliWrapper.h for the class definition +CDaliWrapper::CDaliWrapper() +{ + return; +} diff --git a/dali-csharp-binder/common/DaliWrapper.h b/dali-csharp-binder/common/DaliWrapper.h new file mode 100644 index 00000000..df8f4cac --- /dev/null +++ b/dali-csharp-binder/common/DaliWrapper.h @@ -0,0 +1,43 @@ +/* + * 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. + * + */ + +// The following ifdef block is the standard way of creating macros which make exporting +// from a DLL simpler. All files within this DLL are compiled with the DALIWRAPPER_EXPORTS +// symbol defined on the command line. this symbol should not be defined on any project +// that uses this DLL. This way any other project whose source files include this file see +// DALIWRAPPER_API functions as being imported from a DLL, whereas this DLL sees symbols +// defined with this macro as being exported. + +#ifdef DALIWRAPPER_EXPORTS +#define DALIWRAPPER_API __declspec(dllexport) +#else +#define DALIWRAPPER_API __declspec(dllimport) +#endif + +// This class is exported from the DaliWrapper.dll +class DALIWRAPPER_API CDaliWrapper +{ + +public: + CDaliWrapper(void); + // TODO: add your methods here. + +}; + +extern DALIWRAPPER_API int nDaliWrapper; + +DALIWRAPPER_API int fnDaliWrapper(void); diff --git a/dali-csharp-binder/common/callbackbase-wrap.cpp b/dali-csharp-binder/common/callbackbase-wrap.cpp new file mode 100755 index 00000000..d7e4de8b --- /dev/null +++ b/dali-csharp-binder/common/callbackbase-wrap.cpp @@ -0,0 +1,46 @@ +/* + * 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. + * + */ + +// INTERNAL INCLUDES +#include "common.h" + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MakeCallback(void * jarg1) { + void * jresult ; + void (*arg1)(void) = (void (*)(void)) 0 ; + Dali::CallbackBase *result = 0 ; + + arg1 = (void (*)(void))jarg1; + { + try { + result = (Dali::CallbackBase *)Dali::MakeCallback(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + + jresult = (void *)result; + + return jresult; +} + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/common/common.cpp b/dali-csharp-binder/common/common.cpp new file mode 100644 index 00000000..cf9bc001 --- /dev/null +++ b/dali-csharp-binder/common/common.cpp @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2022 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. + * + */ + +// INTERNAL INCLUDES +#include "common.h" + +void SWIG_ExceptionMessageWithFileAndLine(const int& code, const char* what, const char* filename, const int& linenumber, const char* funcname) +{ + std::string message(what); + std::stringstream fileAndLine; + fileAndLine << " file: " << (filename) << " line: " << (linenumber) << " func: " << (funcname); + message += fileAndLine.str(); + SWIG_CSharpException((code), message.c_str()); +} + +void internal_try_catch(const std::function& func, const char* filename, const int& linenumber, const char* funcname) +{ + try + { + func(); + } + CALL_CATCH_EXCEPTION_WITH_CUSTOM_FILE_AND_LINE(, filename, linenumber, funcname); +} diff --git a/dali-csharp-binder/common/common.h b/dali-csharp-binder/common/common.h new file mode 100755 index 00000000..2051d47c --- /dev/null +++ b/dali-csharp-binder/common/common.h @@ -0,0 +1,368 @@ +#ifndef CSHARP_COMMON_H +#define CSHARP_COMMON_H + +/* + * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#define SWIG_DIRECTORS + +#ifdef __cplusplus +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper +{ + struct SwigMovePointer + { + T *ptr; + SwigMovePointer(T *p) : ptr(p) { } + ~SwigMovePointer() { delete ptr; } + SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } + operator T&() const { return *pointer.ptr; } + T *operator&() { return pointer.ptr; } +}; + +template T SwigValueInit() +{ + return T(); +} +#endif + +#include + +#define SWIGSTDCALL + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +#include +#include +#include +#include + +/* Errors in SWIG */ +constexpr static int SWIG_UnknownError = -1; +constexpr static int SWIG_IOError = -2; +constexpr static int SWIG_RuntimeError = -3; +constexpr static int SWIG_IndexError = -4; +constexpr static int SWIG_TypeError = -5; +constexpr static int SWIG_DivisionByZero = -6; +constexpr static int SWIG_OverflowError = -7; +constexpr static int SWIG_SyntaxError = -8; +constexpr static int SWIG_ValueError = -9; +constexpr static int SWIG_SystemError = -10; +constexpr static int SWIG_AttributeError = -11; +constexpr static int SWIG_MemoryError = -12; +constexpr static int SWIG_NullReferenceError = -13; + +/* Support for throwing C# exceptions from C/C++. There are two types: + * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */ +typedef enum +{ + SWIG_CSharpApplicationException, + SWIG_CSharpArithmeticException, + SWIG_CSharpDivideByZeroException, + SWIG_CSharpIndexOutOfRangeException, + SWIG_CSharpInvalidCastException, + SWIG_CSharpInvalidOperationException, + SWIG_CSharpIOException, + SWIG_CSharpNullReferenceException, + SWIG_CSharpOutOfMemoryException, + SWIG_CSharpOverflowException, + SWIG_CSharpSystemException +} SWIG_CSharpExceptionCodes; + +typedef enum +{ + SWIG_CSharpArgumentException, + SWIG_CSharpArgumentNullException, + SWIG_CSharpArgumentOutOfRangeException +} SWIG_CSharpExceptionArgumentCodes; + +typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *); +typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *); +typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); + +typedef struct +{ + SWIG_CSharpExceptionCodes code; + SWIG_CSharpExceptionCallback_t callback; +} SWIG_CSharpException_t; + +typedef struct +{ + SWIG_CSharpExceptionArgumentCodes code; + SWIG_CSharpExceptionArgumentCallback_t callback; +} SWIG_CSharpExceptionArgument_t; + +extern SWIG_CSharpException_t SWIG_csharp_exceptions[]; + +extern SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[]; + +extern void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg); + +extern void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name); + +extern void SWIG_CSharpException(int code, const char *msg); + + +#include + +#define SWIGSTDCALL + +#include +#include + +// Function to append SWIG_CSharpException message file/line/function. +extern void SWIG_ExceptionMessageWithFileAndLine(const int& code, const char* what, const char* filename, const int& linenumber, const char* funcname); + +#define SWIG_EXCEPTION_WITH_FILE_AND_LINE(code, what) \ +SWIG_ExceptionMessageWithFileAndLine((code), (what), __FILE__, __LINE__, __FUNCTION__) + +// Define Catch exception +#define CALL_CATCH_EXCEPTION(ret) \ + catch (std::out_of_range & e) \ + { \ + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_IndexError, const_cast(e.what())); \ + return ret; \ + } \ + catch (std::exception & e) \ + { \ + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_RuntimeError, const_cast(e.what())); \ + return ret; \ + } \ + catch (Dali::DaliException e) \ + { \ + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_SystemError, e.condition); \ + return ret; \ + } \ + catch (abi::__forced_unwind &) \ + { \ + DALI_LOG_ERROR("abi::__forced_unwind occured\n"); \ + return ret; \ + } \ + catch (...) \ + { \ + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_UnknownError, "unknown error"); \ + return ret; \ + } + +// Define Catch exception with inputed file and line infomations +#define CALL_CATCH_EXCEPTION_WITH_CUSTOM_FILE_AND_LINE(ret, filename, linenumber, funcname) \ + catch (std::out_of_range & e) \ + { \ + SWIG_ExceptionMessageWithFileAndLine(SWIG_IndexError, const_cast(e.what()), (filename), (linenumber), (funcname)); \ + return ret; \ + } \ + catch (std::exception & e) \ + { \ + SWIG_ExceptionMessageWithFileAndLine(SWIG_RuntimeError, const_cast(e.what()), (filename), (linenumber), (funcname)); \ + return ret; \ + } \ + catch (Dali::DaliException e) \ + { \ + SWIG_ExceptionMessageWithFileAndLine(SWIG_SystemError, e.condition, (filename), (linenumber), (funcname)); \ + return ret; \ + } \ + catch (abi::__forced_unwind &) \ + { \ + DALI_LOG_ERROR("abi::__forced_unwind occured\n"); \ + return ret; \ + } \ + catch (...) \ + { \ + SWIG_ExceptionMessageWithFileAndLine(SWIG_UnknownError, "unknown error", (filename), (linenumber), (funcname)); \ + return ret; \ + } + +// Define Catch exception if we need extra job before return +#define CALL_CATCH_EXCEPTION_WITH_FUNCTION(ret, func, ...) \ + catch (std::out_of_range & e) \ + { \ + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_IndexError, const_cast(e.what())); \ + (*(func))(__VA_ARGS__); \ + return ret; \ + } \ + catch (std::exception & e) \ + { \ + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_RuntimeError, const_cast(e.what())); \ + (*(func))(__VA_ARGS__); \ + return ret; \ + } \ + catch (Dali::DaliException e) \ + { \ + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_SystemError, e.condition); \ + (*(func))(__VA_ARGS__); \ + return ret; \ + } \ + catch (abi::__forced_unwind &) \ + { \ + DALI_LOG_ERROR("abi::__forced_unwind occured\n"); \ + (*(func))(__VA_ARGS__); \ + return ret; \ + } \ + catch (...) \ + { \ + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_UnknownError, "unknown error"); \ + (*(func))(__VA_ARGS__); \ + return ret; \ + } + +#define GUARD_ON_NULL_RET(arg_name) \ + if (!(arg_name)) { \ + std::stringstream output; \ + output << __FUNCTION__ << " is not allowed to take nullptr as " << #arg_name; \ + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, output.str().c_str(), #arg_name); \ + return; \ + } + +#define GUARD_ON_NULL_RET0(arg_name) \ + if (!(arg_name)) { \ + std::stringstream output; \ + output << __FUNCTION__ << " is not allowed to take nullptr as " << #arg_name; \ + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, output.str().c_str(), #arg_name); \ + return 0; \ + } + +// Define useful utils with lambda function +extern void internal_try_catch(const std::function& func, const char* filename, const int& linenumber, const char* funcname); + +// Define try_catch macro to get correct line and function_name +// NOTE: when lamda function use comma(,) at template, compiler think this is kind of argment divisor. +// This is compiler bug. So we need to cover the function by additional parentheses. +#define try_catch(func) internal_try_catch((func), __FILE__, __LINE__, __FUNCTION__) + + +// This macro generates 2 functions for signal: +// 1. CSharp_Someclass_SomeSignal_Connect(void* caller, void* handler) +// 2. CSharp_Someclass_SomeSignal_Disconnect(void* caller, void* handler) +// +// Arguments +// - CType: Type of Caller. For example, "Dali::Actor*" +// - HType: Type of Handler. For example, "void(*)(Dali::Actor*)" +// - Prefix: It can be a class name or namespace. This value determines the function name. +// - SignalName: The signal name to be called. For example, "TouchedSignal" +// +#ifndef GENERATE_SIGNAL +#define GENERATE_SIGNAL(CType, HType, Prefix, SignalName) \ + SWIGEXPORT void SWIGSTDCALL CSharp_##Prefix##_##SignalName##_Connect(void* caller, void* handler) \ + { \ + if(!caller) \ + { \ + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Caller (Type :" #CType ") is null", 0); \ + return; \ + } \ + try \ + { \ + ((CType)caller)->SignalName().Connect((HType)handler); \ + } \ + CALL_CATCH_EXCEPTION(); \ + } \ + SWIGEXPORT void SWIGSTDCALL CSharp_##Prefix##_##SignalName##_Disconnect(void* caller, void* handler) \ + { \ + if(!caller) \ + { \ + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Caller (Type :" #CType ") is null", 0); \ + return; \ + } \ + try \ + { \ + ((CType)caller)->SignalName().Disconnect((HType)handler); \ + } \ + CALL_CATCH_EXCEPTION(); \ + } +#endif + +// This macro generates 2 functions for signal declared in Devel class: +// 1. CSharp_Someclass_SomeSignal_Connect(void* caller, void* handler) +// 2. CSharp_Someclass_SomeSignal_Disconnect(void* caller, void* handler) +// +// Arguments +// - CType: Type of Caller. For example, "Dali::Actor*" +// - HType: Type of Handler. For example, "void(*)(Dali::Actor*)" +// - DevelType: Devel namespace. For example, "Dali::DevelActor" +// - Prefix: It can be a class name or namespace. This value determines the function name. +// - SignalName: The signal name to be called. For example, "TouchedSignal" +// +#ifndef GENERATE_DEVEL_SIGNAL +#define GENERATE_DEVEL_SIGNAL(CType, HType, DevelType, Prefix, SignalName) \ + SWIGEXPORT void SWIGSTDCALL CSharp_##Prefix##_##SignalName##_Connect(void* caller, void* handler) \ + { \ + if(!caller) \ + { \ + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Caller (Type :" #CType ") is null", 0); \ + return; \ + } \ + try \ + { \ + DevelType::SignalName(*((CType)caller)).Connect((HType)handler); \ + } \ + CALL_CATCH_EXCEPTION(); \ + } \ + SWIGEXPORT void SWIGSTDCALL CSharp_##Prefix##_##SignalName##_Disconnect(void* caller, void* handler) \ + { \ + if(!caller) \ + { \ + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Caller (Type :" #CType ") is null", 0); \ + return; \ + } \ + try \ + { \ + DevelType::SignalName(*((CType)caller)).Disconnect((HType)handler); \ + } \ + CALL_CATCH_EXCEPTION(); \ + } +#endif + +#endif // CSHARP_COMMON_H diff --git a/dali-csharp-binder/common/dali-wrap.cpp b/dali-csharp-binder/common/dali-wrap.cpp new file mode 100644 index 00000000..7f604cc9 --- /dev/null +++ b/dali-csharp-binder/common/dali-wrap.cpp @@ -0,0 +1,28177 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 3.0.9 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + +#ifndef SWIGCSHARP +#define SWIGCSHARP +#endif + +#define SWIG_DIRECTORS + + +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# elif defined(__HP_aCC) +/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ +/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIG_MSC_UNSUPPRESS_4505 +# if defined(_MSC_VER) +# pragma warning(disable : 4505) /* unreferenced local function has been removed */ +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if defined(__GNUC__) +# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# define _CRT_SECURE_NO_DEPRECATE +#endif + +/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ +#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) +# define _SCL_SECURE_NO_DEPRECATE +#endif + +/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ +#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) +# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 +#endif + +/* Intel's compiler complains if a variable which was never initialised is + * cast to void, which is a common idiom which we use to indicate that we + * are aware a variable isn't used. So we just silence that warning. + * See: https://github.com/swig/swig/issues/192 for more discussion. + */ +#ifdef __INTEL_COMPILER +# pragma warning disable 592 +#endif + +// EXTERNAL INCLUDES +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +// INTERNAL INCLUDES +#include "common.h" + +#include + +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include + +#include + + +SWIG_CSharpException_t SWIG_csharp_exceptions[] = { + { SWIG_CSharpApplicationException, NULL }, + { SWIG_CSharpArithmeticException, NULL }, + { SWIG_CSharpDivideByZeroException, NULL }, + { SWIG_CSharpIndexOutOfRangeException, NULL }, + { SWIG_CSharpInvalidCastException, NULL }, + { SWIG_CSharpInvalidOperationException, NULL }, + { SWIG_CSharpIOException, NULL }, + { SWIG_CSharpNullReferenceException, NULL }, + { SWIG_CSharpOutOfMemoryException, NULL }, + { SWIG_CSharpOverflowException, NULL }, + { SWIG_CSharpSystemException, NULL } +}; + +SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = { + { SWIG_CSharpArgumentException, NULL }, + { SWIG_CSharpArgumentNullException, NULL }, + { SWIG_CSharpArgumentOutOfRangeException, NULL } +}; + +void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) { + SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback; + if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) { + callback = SWIG_csharp_exceptions[code].callback; + } + callback(msg); +} + +void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) { + SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback; + if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) { + callback = SWIG_csharp_exceptions_argument[code].callback; + } + callback(msg, param_name); +} + + +#ifdef __cplusplus +extern "C" +#endif +SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic( + SWIG_CSharpExceptionCallback_t applicationCallback, + SWIG_CSharpExceptionCallback_t arithmeticCallback, + SWIG_CSharpExceptionCallback_t divideByZeroCallback, + SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback, + SWIG_CSharpExceptionCallback_t invalidCastCallback, + SWIG_CSharpExceptionCallback_t invalidOperationCallback, + SWIG_CSharpExceptionCallback_t ioCallback, + SWIG_CSharpExceptionCallback_t nullReferenceCallback, + SWIG_CSharpExceptionCallback_t outOfMemoryCallback, + SWIG_CSharpExceptionCallback_t overflowCallback, + SWIG_CSharpExceptionCallback_t systemCallback) { + SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback; + SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback; + SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback; + SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback; + SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback; + SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback; + SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback; + SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback; + SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback; + SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback; + SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback; +} + +#ifdef __cplusplus +extern "C" +#endif +SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic( + SWIG_CSharpExceptionArgumentCallback_t argumentCallback, + SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback, + SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) { + SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback; + SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback; + SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback; +} + + +/* Callback for returning strings to C# without leaking memory */ +typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); +SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL; + + +#ifdef __cplusplus +extern "C" +#endif +SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) { + SWIG_csharp_string_callback = callback; +} + + +/* Contract support */ +#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else + + +/* ----------------------------------------------------------------------------- + * director_common.swg + * + * This file contains support for director classes which is common between + * languages. + * ----------------------------------------------------------------------------- */ + +/* + Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the + 'Swig' namespace. This could be useful for multi-modules projects. +*/ +#ifdef SWIG_DIRECTOR_STATIC +/* Force anonymous (static) namespace */ +#define Swig +#endif +/* ----------------------------------------------------------------------------- + * director.swg + * + * This file contains support for director classes so that C# proxy + * methods can be called from C++. + * ----------------------------------------------------------------------------- */ + +#if defined(DEBUG_DIRECTOR_OWNED) +#include +#endif + +namespace Swig { + /* Director base class - not currently used in C# directors */ + class Director { + }; + + /* Base class for director exceptions */ + class DirectorException : public std::exception { + protected: + std::string swig_msg; + + public: + DirectorException(const char *msg) : swig_msg(msg) { + } + + DirectorException(const std::string &msg) : swig_msg(msg) { + } + + virtual ~DirectorException() throw() { + } + + const char *what() const throw() { + return swig_msg.c_str(); + } + }; + + /* Pure virtual method exception */ + class DirectorPureVirtualException : public DirectorException { + public: + DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) { + } + }; +} + + +void SWIG_CSharpException(int code, const char *msg) { + if (code == SWIG_ValueError) { + SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException; + SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0); + } else { + SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException; + switch(code) { + case SWIG_MemoryError: + exception_code = SWIG_CSharpOutOfMemoryException; + break; + case SWIG_IndexError: + exception_code = SWIG_CSharpIndexOutOfRangeException; + break; + case SWIG_DivisionByZero: + exception_code = SWIG_CSharpDivideByZeroException; + break; + case SWIG_IOError: + exception_code = SWIG_CSharpIOException; + break; + case SWIG_OverflowError: + exception_code = SWIG_CSharpOverflowException; + break; + case SWIG_RuntimeError: + case SWIG_TypeError: + case SWIG_SyntaxError: + case SWIG_SystemError: + case SWIG_UnknownError: + default: + exception_code = SWIG_CSharpApplicationException; + break; + } + SWIG_CSharpSetPendingException(exception_code, msg); + } +} + + +#define SWIGSTDCALL + +// add here SWIG version check + +#if defined(_MSC_VER) // Microsoft Visual C++ 6.0 +// disable Swig-dependent warnings + +// 'identifier1' has C-linkage specified, +// but returns UDT 'identifier2' which is incompatible with C +#pragma warning(disable: 4190) + +// 'int' : forcing value to bool 'true' or 'false' (performance warning) +#pragma warning(disable: 4800) + +// debug info too long etc etc +#pragma warning(disable: 4786) +#endif + +typedef float floatp; + +SWIGINTERN floatp *new_floatp(){ + return new float(); +} +SWIGINTERN void delete_floatp(floatp *self){ + if (self) delete self; +} +SWIGINTERN void floatp_assign(floatp *self,float value){ + *self = value; +} +SWIGINTERN float floatp_value(floatp *self){ + return *self; +} +SWIGINTERN float *floatp_cast(floatp *self){ + return self; +} +SWIGINTERN floatp *floatp_frompointer(float *t){ + return (floatp *) t; +} + +typedef int intp; + +SWIGINTERN intp *new_intp(){ + return new int(); +} +SWIGINTERN void delete_intp(intp *self){ + if (self) delete self; +} +SWIGINTERN void intp_assign(intp *self,int value){ + *self = value; +} +SWIGINTERN int intp_value(intp *self){ + return *self; +} +SWIGINTERN int *intp_cast(intp *self){ + return self; +} +SWIGINTERN intp *intp_frompointer(int *t){ + return (intp *) t; +} + +typedef double doublep; + +SWIGINTERN doublep *new_doublep(){ + return new double(); +} +SWIGINTERN void delete_doublep(doublep *self){ + if (self) delete self; +} +SWIGINTERN void doublep_assign(doublep *self,double value){ + *self = value; +} +SWIGINTERN double doublep_value(doublep *self){ + return *self; +} +SWIGINTERN double *doublep_cast(doublep *self){ + return self; +} +SWIGINTERN doublep *doublep_frompointer(double *t){ + return (doublep *) t; +} + +typedef unsigned int uintp; + +SWIGINTERN uintp *new_uintp(){ + return new unsigned int(); +} +SWIGINTERN void delete_uintp(uintp *self){ + if (self) delete self; +} +SWIGINTERN void uintp_assign(uintp *self,unsigned int value){ + *self = value; +} +SWIGINTERN unsigned int uintp_value(uintp *self){ + return *self; +} +SWIGINTERN unsigned int *uintp_cast(uintp *self){ + return self; +} +SWIGINTERN uintp *uintp_frompointer(unsigned int *t){ + return (uintp *) t; +} + +typedef unsigned short ushortp; + +SWIGINTERN ushortp *new_ushortp(){ + return new unsigned short(); +} +SWIGINTERN void delete_ushortp(ushortp *self){ + if (self) delete self; +} +SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){ + *self = value; +} +SWIGINTERN unsigned short ushortp_value(ushortp *self){ + return *self; +} +SWIGINTERN unsigned short *ushortp_cast(ushortp *self){ + return self; +} +SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){ + return (ushortp *) t; +} + +unsigned int int_to_uint(int x) { + return (unsigned int) x; +} + + +using namespace Dali; +using namespace Dali::Toolkit; + +SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self) +{ + bool result = false; + try + { + // 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 mObjectHandle in BaseHandle; + if( *self ) + { + result = true; + } + else + { + result = false; + } + } + CALL_CATCH_EXCEPTION(false); + return result; +} + +SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs) +{ + bool result = false; + try + { + // C++ code. Check if two handles reference the same implemtion + if( *self == rhs) + { + result = true; + } + else + { + result = false; + } + } + CALL_CATCH_EXCEPTION(false); + return result; +} + + +SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){ + Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc ); + } +SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){ + Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc ); + } +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) { + pv = new std::vector< Dali::TouchPoint >(); + pv->reserve(capacity); + } else { + throw std::out_of_range("capacity"); + } + return pv; + } +SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){ + if (index>=0 && index<(int)self->size()) + return (*self)[index]; + else + throw std::out_of_range("index"); + } +SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){ + if (index>=0 && index<(int)self->size()) + return (*self)[index]; + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){ + if (index>=0 && index<(int)self->size()) + (*self)[index] = val; + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){ + self->insert(self->end(), values.begin(), values.end()); + } +SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){ + if (index < 0) + throw std::out_of_range("index"); + if (count < 0) + throw std::out_of_range("count"); + if (index >= (int)self->size()+1 || index+count > (int)self->size()) + throw std::invalid_argument("invalid range"); + return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count); + } +SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){ + if (index>=0 && index<(int)self->size()+1) + self->insert(self->begin()+index, x); + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){ + if (index>=0 && index<(int)self->size()+1) + self->insert(self->begin()+index, values.begin(), values.end()); + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){ + if (index>=0 && index<(int)self->size()) + self->erase(self->begin() + index); + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){ + if (index < 0) + throw std::out_of_range("index"); + if (count < 0) + throw std::out_of_range("count"); + if (index >= (int)self->size()+1 || index+count > (int)self->size()) + throw std::invalid_argument("invalid range"); + self->erase(self->begin()+index, self->begin()+index+count); + } +SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){ + if (count < 0) + throw std::out_of_range("count"); + return new std::vector< Dali::TouchPoint >(count, value); + } +SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){ + std::reverse(self->begin(), self->end()); + } +SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){ + if (index < 0) + throw std::out_of_range("index"); + if (count < 0) + throw std::out_of_range("count"); + if (index >= (int)self->size()+1 || index+count > (int)self->size()) + throw std::invalid_argument("invalid range"); + std::reverse(self->begin()+index, self->begin()+index+count); + } +SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){ + if (index < 0) + throw std::out_of_range("index"); + if (index+values.size() > self->size()) + throw std::out_of_range("index"); + std::copy(values.begin(), values.end(), self->begin()+index); + } +SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){ + return self->Empty(); + } +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){ + return self->GetConnectionCount(); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){ + self->Connect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){ + self->Disconnect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg ); + } +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){ + return self->Empty(); + } +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){ + return self->GetConnectionCount(); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){ + self->Connect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){ + self->Disconnect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg ); + } +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){ + return self->Empty(); + } +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){ + return self->GetConnectionCount(); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){ + self->Connect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){ + self->Disconnect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg ); + } +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){ + return self->Empty(); + } +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){ + return self->GetConnectionCount(); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){ + self->Connect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){ + self->Disconnect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg1, arg2 ); + } +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){ + return self->Empty(); + } +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){ + return self->GetConnectionCount(); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){ + self->Connect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){ + self->Disconnect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg ); + } +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchEvent const &) > const *self){ + return self->Empty(); + } +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchEvent const &) > const *self){ + return self->GetConnectionCount(); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchEvent const &) > *self,void (*func)(Dali::TouchEvent const &)){ + self->Connect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchEvent const &) > *self,void (*func)(Dali::TouchEvent const &)){ + self->Disconnect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchEvent const &) > *self,Dali::TouchEvent const &arg){ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg ); + } +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){ + return self->Empty(); + } +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){ + return self->GetConnectionCount(); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){ + self->Connect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){ + self->Disconnect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg ); + } +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){ + return self->Empty(); + } +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){ + return self->GetConnectionCount(); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){ + self->Connect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){ + self->Disconnect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg1, arg2 ); + } +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){ + return self->Empty(); + } +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){ + return self->GetConnectionCount(); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){ + self->Connect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){ + self->Disconnect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg1, arg2 ); + } +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){ + return self->Empty(); + } +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){ + return self->GetConnectionCount(); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){ + self->Connect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){ + self->Disconnect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg1, arg2 ); + } +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){ + return self->Empty(); + } +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){ + return self->GetConnectionCount(); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){ + return self->Connect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){ + self->Disconnect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){ + self->Emit( arg1, arg3 ); + } +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){ + return self->Empty(); + } +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){ + return self->GetConnectionCount(); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){ + return self->Connect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){ + self->Disconnect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg1, arg2, arg3 ); + } + +SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){ + std::vector< unsigned int >* pv = 0; + if (capacity >= 0) { + pv = new std::vector< unsigned int >(); + pv->reserve(capacity); + } else { + throw std::out_of_range("capacity"); + } + return pv; + } +SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){ + if (index>=0 && index<(int)self->size()) + return (*self)[index]; + else + throw std::out_of_range("index"); + } +SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){ + if (index>=0 && index<(int)self->size()) + return (*self)[index]; + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){ + if (index>=0 && index<(int)self->size()) + (*self)[index] = val; + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){ + self->insert(self->end(), values.begin(), values.end()); + } +SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){ + if (index < 0) + throw std::out_of_range("index"); + if (count < 0) + throw std::out_of_range("count"); + if (index >= (int)self->size()+1 || index+count > (int)self->size()) + throw std::invalid_argument("invalid range"); + return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){ + if (index>=0 && index<(int)self->size()+1) + self->insert(self->begin()+index, x); + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){ + if (index>=0 && index<(int)self->size()+1) + self->insert(self->begin()+index, values.begin(), values.end()); + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){ + if (index>=0 && index<(int)self->size()) + self->erase(self->begin() + index); + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){ + if (index < 0) + throw std::out_of_range("index"); + if (count < 0) + throw std::out_of_range("count"); + if (index >= (int)self->size()+1 || index+count > (int)self->size()) + throw std::invalid_argument("invalid range"); + self->erase(self->begin()+index, self->begin()+index+count); + } +SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){ + if (count < 0) + throw std::out_of_range("count"); + return new std::vector< unsigned int >(count, value); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){ + std::reverse(self->begin(), self->end()); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){ + if (index < 0) + throw std::out_of_range("index"); + if (count < 0) + throw std::out_of_range("count"); + if (index >= (int)self->size()+1 || index+count > (int)self->size()) + throw std::invalid_argument("invalid range"); + std::reverse(self->begin()+index, self->begin()+index+count); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){ + if (index < 0) + throw std::out_of_range("index"); + if (index+values.size() > self->size()) + throw std::out_of_range("index"); + std::copy(values.begin(), values.end(), self->begin()+index); + } +SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){ + return std::find(self->begin(), self->end(), value) != self->end(); + } +SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){ + int index = -1; + std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value); + if (it != self->end()) + index = (int)(it - self->begin()); + return index; + } +SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){ + int index = -1; + std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value); + if (rit != self->rend()) + index = (int)(self->rend() - 1 - rit); + return index; + } +SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){ + std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value); + if (it != self->end()) { + self->erase(it); + return true; + } + return false; + } +SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){ + std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0; + if (capacity >= 0) { + pv = new std::vector< std::pair< unsigned int,Dali::Actor > >(); + pv->reserve(capacity); + } else { + throw std::out_of_range("capacity"); + } + return pv; + } +SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){ + if (index>=0 && index<(int)self->size()) + return (*self)[index]; + else + throw std::out_of_range("index"); + } +SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){ + if (index>=0 && index<(int)self->size()) + return (*self)[index]; + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){ + if (index>=0 && index<(int)self->size()) + (*self)[index] = val; + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){ + self->insert(self->end(), values.begin(), values.end()); + } +SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){ + if (index < 0) + throw std::out_of_range("index"); + if (count < 0) + throw std::out_of_range("count"); + if (index >= (int)self->size()+1 || index+count > (int)self->size()) + throw std::invalid_argument("invalid range"); + return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count); + } +SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){ + if (index>=0 && index<(int)self->size()+1) + self->insert(self->begin()+index, x); + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){ + if (index>=0 && index<(int)self->size()+1) + self->insert(self->begin()+index, values.begin(), values.end()); + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){ + if (index>=0 && index<(int)self->size()) + self->erase(self->begin() + index); + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){ + if (index < 0) + throw std::out_of_range("index"); + if (count < 0) + throw std::out_of_range("count"); + if (index >= (int)self->size()+1 || index+count > (int)self->size()) + throw std::invalid_argument("invalid range"); + self->erase(self->begin()+index, self->begin()+index+count); + } +SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){ + if (count < 0) + throw std::out_of_range("count"); + return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value); + } +SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){ + std::reverse(self->begin(), self->end()); + } +SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){ + if (index < 0) + throw std::out_of_range("index"); + if (count < 0) + throw std::out_of_range("count"); + if (index >= (int)self->size()+1 || index+count > (int)self->size()) + throw std::invalid_argument("invalid range"); + std::reverse(self->begin()+index, self->begin()+index+count); + } +SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){ + if (index < 0) + throw std::out_of_range("index"); + if (index+values.size() > self->size()) + throw std::out_of_range("index"); + std::copy(values.begin(), values.end(), self->begin()+index); + } +SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){ + std::vector< Dali::Actor >* pv = 0; + if (capacity >= 0) { + pv = new std::vector< Dali::Actor >(); + pv->reserve(capacity); + } else { + throw std::out_of_range("capacity"); + } + return pv; + } +SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){ + if (index>=0 && index<(int)self->size()) + return (*self)[index]; + else + throw std::out_of_range("index"); + } +SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){ + if (index>=0 && index<(int)self->size()) + return (*self)[index]; + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){ + if (index>=0 && index<(int)self->size()) + (*self)[index] = val; + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){ + self->insert(self->end(), values.begin(), values.end()); + } +SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){ + if (index < 0) + throw std::out_of_range("index"); + if (count < 0) + throw std::out_of_range("count"); + if (index >= (int)self->size()+1 || index+count > (int)self->size()) + throw std::invalid_argument("invalid range"); + return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count); + } +SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){ + if (index>=0 && index<(int)self->size()+1) + self->insert(self->begin()+index, x); + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){ + if (index>=0 && index<(int)self->size()+1) + self->insert(self->begin()+index, values.begin(), values.end()); + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){ + if (index>=0 && index<(int)self->size()) + self->erase(self->begin() + index); + else + throw std::out_of_range("index"); + } +SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){ + if (index < 0) + throw std::out_of_range("index"); + if (count < 0) + throw std::out_of_range("count"); + if (index >= (int)self->size()+1 || index+count > (int)self->size()) + throw std::invalid_argument("invalid range"); + self->erase(self->begin()+index, self->begin()+index+count); + } +SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){ + if (count < 0) + throw std::out_of_range("count"); + return new std::vector< Dali::Actor >(count, value); + } +SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){ + std::reverse(self->begin(), self->end()); + } +SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){ + if (index < 0) + throw std::out_of_range("index"); + if (count < 0) + throw std::out_of_range("count"); + if (index >= (int)self->size()+1 || index+count > (int)self->size()) + throw std::invalid_argument("invalid range"); + std::reverse(self->begin()+index, self->begin()+index+count); + } +SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){ + if (index < 0) + throw std::out_of_range("index"); + if (index+values.size() > self->size()) + throw std::out_of_range("index"); + std::copy(values.begin(), values.end(), self->begin()+index); + } +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){ + return self->Empty(); + } +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){ + return self->GetConnectionCount(); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){ + self->Connect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){ + self->Disconnect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg1, arg2 ); + } +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){ + return self->Empty(); + } +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){ + return self->GetConnectionCount(); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){ + self->Connect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){ + self->Disconnect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg1, arg2 ); + } + +/* --------------------------------------------------- + * C++ director class methods + * --------------------------------------------------- */ + +#include "dali-wrap.h" + +/* + * Widget director + */ +SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() { + swig_init_callbacks(); +} + +SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() { +} + +void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) { + char * jcontentInfo = 0 ; + void * jwindow ; + + if (!swig_callbackOnCreate) { + Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window); + return; + } else { + jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str()); + jwindow = (void *)new Dali::Window((const Dali::Window &)window); + swig_callbackOnCreate(jcontentInfo, jwindow); + } +} + +void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) { + char * jcontentInfo = 0 ; + int jtype ; + + if (!swig_callbackOnTerminate) { + Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type); + return; + } else { + jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str()); + jtype = (int)type; + swig_callbackOnTerminate(jcontentInfo, jtype); + } +} + +void SwigDirector_WidgetImpl::OnPause() { + if (!swig_callbackOnPause) { + Dali::Internal::Adaptor::Widget::OnPause(); + return; + } else { + swig_callbackOnPause(); + } +} + +void SwigDirector_WidgetImpl::OnResume() { + if (!swig_callbackOnResume) { + Dali::Internal::Adaptor::Widget::OnResume(); + return; + } else { + swig_callbackOnResume(); + } +} + +void SwigDirector_WidgetImpl::OnResize(Dali::Window window) { + void * jwindow ; + + if (!swig_callbackOnResize) { + Dali::Internal::Adaptor::Widget::OnResize(window); + return; + } else { + jwindow = (void *)new Dali::Window((const Dali::Window &)window); + swig_callbackOnResize(jwindow); + } +} + +void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) { + char * jcontentInfo = 0 ; + int jforce ; + + if (!swig_callbackOnUpdate) { + Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force); + return; + } else { + jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str()); + jforce = force; + swig_callbackOnUpdate(jcontentInfo, jforce); + } +} + +void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) { + void * jslotObserver = 0 ; + void * jcallback = 0 ; + + if (!swig_callbackSignalConnected) { + Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback); + return; + } else { + jslotObserver = (void *) slotObserver; + jcallback = (void *) callback; + swig_callbackSignalConnected(jslotObserver, jcallback); + } +} + +void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) { + void * jslotObserver = 0 ; + void * jcallback = 0 ; + + if (!swig_callbackSignalDisconnected) { + Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback); + return; + } else { + jslotObserver = (void *) slotObserver; + jcallback = (void *) callback; + swig_callbackSignalDisconnected(jslotObserver, jcallback); + } +} + +void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) { + + swig_callbackOnCreate = callbackOnCreate; + swig_callbackOnTerminate = callbackOnTerminate; + swig_callbackOnPause = callbackOnPause; + swig_callbackOnResume = callbackOnResume; + swig_callbackOnResize = callbackOnResize; + swig_callbackOnUpdate = callbackOnUpdate; + swig_callbackSignalConnected = callbackSignalConnected; + swig_callbackSignalDisconnected = callbackSignalDisconnected; +} + +void SwigDirector_WidgetImpl::swig_init_callbacks() { + swig_callbackOnCreate = 0; + swig_callbackOnTerminate = 0; + swig_callbackOnPause = 0; + swig_callbackOnResume = 0; + swig_callbackOnResize = 0; + swig_callbackOnUpdate = 0; + swig_callbackSignalConnected = 0; + swig_callbackSignalDisconnected = 0; +} + + +SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() { + swig_init_callbacks(); +} + +SwigDirector_ViewImpl::~SwigDirector_ViewImpl() { + +} + + +void SwigDirector_ViewImpl::OnSceneConnection(int depth) { + int jdepth ; + + if (!swig_callbackOnSceneConnection) { + Dali::Toolkit::Internal::Control::OnSceneConnection(depth); + return; + } else { + jdepth = depth; + swig_callbackOnSceneConnection(jdepth); + } +} + +void SwigDirector_ViewImpl::OnSceneDisconnection() { + if (!swig_callbackOnSceneDisconnection) { + Dali::Toolkit::Internal::Control::OnSceneDisconnection(); + return; + } else { + swig_callbackOnSceneDisconnection(); + } +} + +void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) { + void * jchild = 0 ; + + if (!swig_callbackOnChildAdd) { + Dali::Toolkit::Internal::Control::OnChildAdd(child); + return; + } else { + jchild = (Dali::Actor *) &child; + swig_callbackOnChildAdd(jchild); + } +} + +void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) { + void * jchild = 0 ; + + if (!swig_callbackOnChildRemove) { + Dali::Toolkit::Internal::Control::OnChildRemove(child); + return; + } else { + jchild = (Dali::Actor *) &child; + swig_callbackOnChildRemove(jchild); + } +} + +void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, const Dali::Property::Value& propertyValue) { + int jindex ; + void * jpropertyValue ; + + if (!swig_callbackOnPropertySet) { + Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue); + return; + } else { + jindex = index; + jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue); + swig_callbackOnPropertySet(jindex, jpropertyValue); + } +} + +void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) { + void * jtargetSize = 0 ; + + if (!swig_callbackOnSizeSet) { + Dali::Toolkit::Internal::Control::OnSizeSet(targetSize); + return; + } else { + jtargetSize = (Dali::Vector3 *) &targetSize; + swig_callbackOnSizeSet(jtargetSize); + } +} + +void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) { + void * janimation = 0 ; + void * jtargetSize = 0 ; + + if (!swig_callbackOnSizeAnimation) { + Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize); + return; + } else { + janimation = (Dali::Animation *) &animation; + jtargetSize = (Dali::Vector3 *) &targetSize; + swig_callbackOnSizeAnimation(janimation, jtargetSize); + } +} + +bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + void * jarg0 = 0 ; + + if (!swig_callbackOnKeyEvent) { + return Dali::Toolkit::Internal::Control::OnKeyEvent(event); + } else { + jarg0 = (Dali::KeyEvent *) &event; + jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0); + c_result = jresult ? true : false; + } + return c_result; +} + +void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) { + void * jsize = 0 ; + void * jcontainer = 0 ; + + if (!swig_callbackOnRelayout) { + Dali::Toolkit::Internal::Control::OnRelayout(size,container); + return; + } else { + jsize = (Dali::Vector2 *) &size; + jcontainer = (Dali::RelayoutContainer *) &container; + swig_callbackOnRelayout(jsize, jcontainer); + } +} + +void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) { + int jpolicy ; + int jdimension ; + + if (!swig_callbackOnSetResizePolicy) { + Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension); + return; + } else { + jpolicy = (int)policy; + jdimension = (int)dimension; + swig_callbackOnSetResizePolicy(jpolicy, jdimension); + } +} + +Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() { + Dali::Vector3 c_result ; + void * jresult = 0 ; + + if (!swig_callbackGetNaturalSize) { + return Dali::Toolkit::Internal::Control::GetNaturalSize(); + } else { + jresult = (void *) swig_callbackGetNaturalSize(); + if (!jresult) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0); + return c_result; + } + c_result = *(Dali::Vector3 *)jresult; + } + return c_result; +} + +float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) { + float c_result = SwigValueInit< float >() ; + float jresult = 0 ; + void * jchild = 0 ; + int jdimension ; + + if (!swig_callbackCalculateChildSize) { + return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension); + } else { + jchild = (Dali::Actor *) &child; + jdimension = (int)dimension; + jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension); + c_result = (float)jresult; + } + return c_result; +} + +float SwigDirector_ViewImpl::GetHeightForWidth(float width) { + float c_result = SwigValueInit< float >() ; + float jresult = 0 ; + float jwidth ; + + if (!swig_callbackGetHeightForWidth) { + return Dali::Toolkit::Internal::Control::GetHeightForWidth(width); + } else { + jwidth = width; + jresult = (float) swig_callbackGetHeightForWidth(jwidth); + c_result = (float)jresult; + } + return c_result; +} + +float SwigDirector_ViewImpl::GetWidthForHeight(float height) { + float c_result = SwigValueInit< float >() ; + float jresult = 0 ; + float jheight ; + + if (!swig_callbackGetWidthForHeight) { + return Dali::Toolkit::Internal::Control::GetWidthForHeight(height); + } else { + jheight = height; + jresult = (float) swig_callbackGetWidthForHeight(jheight); + c_result = (float)jresult; + } + return c_result; +} + +bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + int jdimension ; + + if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) { + return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension); + } else { + jdimension = (int)dimension; + jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension); + c_result = jresult ? true : false; + } + return c_result; +} + +void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) { + int jdimension ; + + if (!swig_callbackOnCalculateRelayoutSize) { + Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension); + return; + } else { + jdimension = (int)dimension; + swig_callbackOnCalculateRelayoutSize(jdimension); + } +} + +void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) { + float jsize ; + int jdimension ; + + if (!swig_callbackOnLayoutNegotiated) { + Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension); + return; + } else { + jsize = size; + jdimension = (int)dimension; + swig_callbackOnLayoutNegotiated(jsize, jdimension); + } +} + +Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() { + return Dali::CustomActorImpl::GetExtension(); +} + +void SwigDirector_ViewImpl::OnInitialize() { + if (!swig_callbackOnInitialize) { + Dali::Toolkit::Internal::Control::OnInitialize(); + return; + } else { + swig_callbackOnInitialize(); + } +} + +void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) { + void * jstyleManager ; + int jchange ; + + if (!swig_callbackOnStyleChange) { + Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change); + return; + } else { + jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager); + jchange = (int)change; + swig_callbackOnStyleChange(jstyleManager, jchange); + } +} + +bool SwigDirector_ViewImpl::OnAccessibilityActivated() { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + + if (!swig_callbackOnAccessibilityActivated) { + return Dali::Toolkit::Internal::Control::OnAccessibilityActivated(); + } else { + jresult = (unsigned int) swig_callbackOnAccessibilityActivated(); + c_result = jresult ? true : false; + } + return c_result; +} + +bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + void * jgesture ; + + if (!swig_callbackOnAccessibilityPan) { + return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture); + } else { + jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture); + jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture); + c_result = jresult ? true : false; + } + return c_result; +} + +bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + unsigned int jisIncrease ; + + if (!swig_callbackOnAccessibilityValueChange) { + return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease); + } else { + jisIncrease = isIncrease; + jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease); + c_result = jresult ? true : false; + } + return c_result; +} + +bool SwigDirector_ViewImpl::OnAccessibilityZoom() { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + + if (!swig_callbackOnAccessibilityZoom) { + return Dali::Toolkit::Internal::Control::OnAccessibilityZoom(); + } else { + jresult = (unsigned int) swig_callbackOnAccessibilityZoom(); + c_result = jresult ? true : false; + } + return c_result; +} + +void SwigDirector_ViewImpl::OnKeyInputFocusGained() { + if (!swig_callbackOnKeyInputFocusGained) { + Dali::Toolkit::Internal::Control::OnKeyInputFocusGained(); + return; + } else { + swig_callbackOnKeyInputFocusGained(); + } +} + +void SwigDirector_ViewImpl::OnKeyInputFocusLost() { + if (!swig_callbackOnKeyInputFocusLost) { + Dali::Toolkit::Internal::Control::OnKeyInputFocusLost(); + return; + } else { + swig_callbackOnKeyInputFocusLost(); + } +} + + +Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) +{ + Dali::Actor c_result; + void* jresult = 0; + + if(!swig_callbackGetNextKeyboardFocusableActor) + { + return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled); + } + else + { + jresult = (void*)swig_callbackGetNextKeyboardFocusableActor((void*)(¤tFocusedActor), (int)direction, loopEnabled); + + if(!jresult) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0); + return c_result; + } + c_result = *(Dali::Actor*)jresult; + } + return c_result; +} + +void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) +{ + if(!swig_callbackOnKeyboardFocusChangeCommitted) + { + Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor); + return; + } + else + { + swig_callbackOnKeyboardFocusChangeCommitted((void*)(&commitedFocusableActor)); + } +} + +bool SwigDirector_ViewImpl::OnKeyboardEnter() { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + + if (!swig_callbackOnKeyboardEnter) { + return Dali::Toolkit::Internal::Control::OnKeyboardEnter(); + } else { + jresult = (unsigned int) swig_callbackOnKeyboardEnter(); + c_result = jresult ? true : false; + } + return c_result; +} + +void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) { + void * jpinch = 0 ; + + if (!swig_callbackOnPinch) { + Dali::Toolkit::Internal::Control::OnPinch(pinch); + return; + } else { + jpinch = (Dali::PinchGesture *) &pinch; + swig_callbackOnPinch(jpinch); + } +} + +void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) { + void * jpan = 0 ; + + if (!swig_callbackOnPan) { + Dali::Toolkit::Internal::Control::OnPan(pan); + return; + } else { + jpan = (Dali::PanGesture *) &pan; + swig_callbackOnPan(jpan); + } +} + +void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) { + void * jtap = 0 ; + + if (!swig_callbackOnTap) { + Dali::Toolkit::Internal::Control::OnTap(tap); + return; + } else { + jtap = (Dali::TapGesture *) &tap; + swig_callbackOnTap(jtap); + } +} + +void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) { + void * jlongPress = 0 ; + + if (!swig_callbackOnLongPress) { + Dali::Toolkit::Internal::Control::OnLongPress(longPress); + return; + } else { + jlongPress = (Dali::LongPressGesture *) &longPress; + swig_callbackOnLongPress(jlongPress); + } +} + +void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) { + void * jslotObserver = 0 ; + void * jcallback = 0 ; + + if (!swig_callbackSignalConnected) { + Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback); + return; + } else { + jslotObserver = (void *) slotObserver; + jcallback = (void *) callback; + swig_callbackSignalConnected(jslotObserver, jcallback); + } +} + +void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) { + void * jslotObserver = 0 ; + void * jcallback = 0 ; + + if (!swig_callbackSignalDisconnected) { + Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback); + return; + } else { + jslotObserver = (void *) slotObserver; + jcallback = (void *) callback; + swig_callbackSignalDisconnected(jslotObserver, jcallback); + } +} + +Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() { + return Dali::Toolkit::Internal::Control::GetControlExtension(); +} + +void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnSceneConnection, SWIG_Callback1_t callbackOnSceneDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) { + swig_callbackOnSceneConnection = callbackOnSceneConnection; + swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection; + swig_callbackOnChildAdd = callbackOnChildAdd; + swig_callbackOnChildRemove = callbackOnChildRemove; + swig_callbackOnPropertySet = callbackOnPropertySet; + swig_callbackOnSizeSet = callbackOnSizeSet; + swig_callbackOnSizeAnimation = callbackOnSizeAnimation; + swig_callbackOnKeyEvent = callbackOnKeyEvent; + swig_callbackOnRelayout = callbackOnRelayout; + swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy; + swig_callbackGetNaturalSize = callbackGetNaturalSize; + swig_callbackCalculateChildSize = callbackCalculateChildSize; + swig_callbackGetHeightForWidth = callbackGetHeightForWidth; + swig_callbackGetWidthForHeight = callbackGetWidthForHeight; + swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0; + swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1; + swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize; + swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated; + swig_callbackOnInitialize = callbackOnInitialize; + swig_callbackOnStyleChange = callbackOnStyleChange; + swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated; + swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan; + swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange; + swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom; + swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained; + swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost; + swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor; + swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted; + swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter; + swig_callbackOnPinch = callbackOnPinch; + swig_callbackOnPan = callbackOnPan; + swig_callbackOnTap = callbackOnTap; + swig_callbackOnLongPress = callbackOnLongPress; + swig_callbackSignalConnected = callbackSignalConnected; + swig_callbackSignalDisconnected = callbackSignalDisconnected; +} + +void SwigDirector_ViewImpl::swig_init_callbacks() { + swig_callbackOnSceneConnection = 0; + swig_callbackOnSceneDisconnection = 0; + swig_callbackOnChildAdd = 0; + swig_callbackOnChildRemove = 0; + swig_callbackOnPropertySet = 0; + swig_callbackOnSizeSet = 0; + swig_callbackOnSizeAnimation = 0; + swig_callbackOnKeyEvent = 0; + swig_callbackOnRelayout = 0; + swig_callbackOnSetResizePolicy = 0; + swig_callbackGetNaturalSize = 0; + swig_callbackCalculateChildSize = 0; + swig_callbackGetHeightForWidth = 0; + swig_callbackGetWidthForHeight = 0; + swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0; + swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0; + swig_callbackOnCalculateRelayoutSize = 0; + swig_callbackOnLayoutNegotiated = 0; + swig_callbackOnInitialize = 0; + swig_callbackOnStyleChange = 0; + swig_callbackOnAccessibilityActivated = 0; + swig_callbackOnAccessibilityPan = 0; + swig_callbackOnAccessibilityValueChange = 0; + swig_callbackOnAccessibilityZoom = 0; + swig_callbackOnKeyInputFocusGained = 0; + swig_callbackOnKeyInputFocusLost = 0; + swig_callbackGetNextKeyboardFocusableActor = 0; + swig_callbackOnKeyboardFocusChangeCommitted = 0; + swig_callbackOnKeyboardEnter = 0; + swig_callbackOnPinch = 0; + swig_callbackOnPan = 0; + swig_callbackOnTap = 0; + swig_callbackOnLongPress = 0; + swig_callbackSignalConnected = 0; + swig_callbackSignalDisconnected = 0; +} + +SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() { + swig_init_callbacks(); +} + +SwigDirector_ItemFactory::~SwigDirector_ItemFactory() { + +} + + +unsigned int SwigDirector_ItemFactory::GetNumberOfItems() { + unsigned int c_result = SwigValueInit< unsigned int >() ; + unsigned int jresult = 0 ; + + if (!swig_callbackGetNumberOfItems) { + throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems"); + } else { + jresult = (unsigned int) swig_callbackGetNumberOfItems(); + c_result = (unsigned int)jresult; + } + return c_result; +} + +Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) { + Dali::Actor c_result ; + void * jresult = 0 ; + unsigned int jitemId ; + + if (!swig_callbackNewItem) { + throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem"); + } else { + jitemId = itemId; + jresult = (void *) swig_callbackNewItem(jitemId); + if (!jresult) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0); + return c_result; + } + c_result = *(Dali::Actor *)jresult; + } + return c_result; +} + +void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) +{ + if(!swig_callbackItemReleased) + { + Dali::Toolkit::ItemFactory::ItemReleased(itemId, actor); + return; + } + else + { + swig_callbackItemReleased(itemId, (void*)(&actor)); + } +} + +Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() { + return Dali::Toolkit::ItemFactory::GetExtension(); +} + +void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) { + swig_callbackGetNumberOfItems = callbackGetNumberOfItems; + swig_callbackNewItem = callbackNewItem; + swig_callbackItemReleased = callbackItemReleased; +} + +void SwigDirector_ItemFactory::swig_init_callbacks() { + swig_callbackGetNumberOfItems = 0; + swig_callbackNewItem = 0; + swig_callbackItemReleased = 0; +} + +SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() { + swig_init_callbacks(); +} + +SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() { + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() { + void * jresult ; + Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ; + + { + try { + result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction, const std::string& deviceName) +{ + Dali::Actor c_result; + void* jresult = 0; + + if(!swig_callbackGetNextFocusableActor) + { + throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor"); + } + else + { + jresult = (void*)swig_callbackGetNextFocusableActor((void*)(¤t), (void*)(&proposed), direction, deviceName.c_str()); + if(!jresult) + { + DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::Actor! Next focus will be NULL, please be cautious to handle the keyboard foucs!", __FILE__, __LINE__); + return c_result; + } + c_result = *(Dali::Actor*)jresult; + } + return c_result; +} + +void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) { + swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor; +} + +void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() { + swig_callbackGetNextFocusableActor = 0; +} + +SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() { + swig_callbackOnUpdate = 0; +} + +SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() { + +} + +void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) { + swig_callbackOnUpdate = callbackUpdate; +} + + +bool SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) { + void * jcurrent ; + + if (!swig_callbackOnUpdate) { + throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update"); + } else { + Dali::UpdateProxy* proxy = &updateProxy; + jcurrent = (void *)proxy; + swig_callbackOnUpdate(jcurrent, elapsedSeconds); + if (!jcurrent) { + DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__); + return false; + } + } + return false; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) { + Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2; + SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast(obj); + + Dali::Stage *arg1 = (Dali::Stage *) 0; + Dali::Actor *arg3 = 0; + + arg1 = (Dali::Stage *)jarg1; + arg3 = (Dali::Actor *)jarg3; + + DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 ); + return; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) { + + Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2; + SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast(obj); + + Dali::Stage *arg1 = (Dali::Stage *) 0; + + arg1 = (Dali::Stage *)jarg1; + + DevelStage::RemoveFrameCallback( *arg1, *arg2 ); + return; +} + + +/*******************************************/ +/* Binding */ +/*******************************************/ + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() { + void * jresult ; + floatp *result = 0 ; + + { + try { + result = (floatp *)new_floatp(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) { + floatp *arg1 = (floatp *) 0 ; + + arg1 = (floatp *)jarg1; + { + try { + delete_floatp(arg1); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) { + floatp *arg1 = (floatp *) 0 ; + float arg2 ; + + arg1 = (floatp *)jarg1; + arg2 = (float)jarg2; + { + try { + floatp_assign(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) { + float jresult ; + floatp *arg1 = (floatp *) 0 ; + float result; + + arg1 = (floatp *)jarg1; + { + try { + result = (float)floatp_value(arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) { + void * jresult ; + floatp *arg1 = (floatp *) 0 ; + float *result = 0 ; + + arg1 = (floatp *)jarg1; + { + try { + result = (float *)floatp_cast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) { + void * jresult ; + float *arg1 = (float *) 0 ; + floatp *result = 0 ; + + arg1 = (float *)jarg1; + { + try { + result = (floatp *)floatp_frompointer(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() { + void * jresult ; + intp *result = 0 ; + + { + try { + result = (intp *)new_intp(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) { + intp *arg1 = (intp *) 0 ; + + arg1 = (intp *)jarg1; + { + try { + delete_intp(arg1); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) { + intp *arg1 = (intp *) 0 ; + int arg2 ; + + arg1 = (intp *)jarg1; + arg2 = (int)jarg2; + { + try { + intp_assign(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) { + int jresult ; + intp *arg1 = (intp *) 0 ; + int result; + + arg1 = (intp *)jarg1; + { + try { + result = (int)intp_value(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) { + void * jresult ; + intp *arg1 = (intp *) 0 ; + int *result = 0 ; + + arg1 = (intp *)jarg1; + { + try { + result = (int *)intp_cast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) { + void * jresult ; + int *arg1 = (int *) 0 ; + intp *result = 0 ; + + arg1 = (int *)jarg1; + { + try { + result = (intp *)intp_frompointer(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() { + void * jresult ; + doublep *result = 0 ; + + { + try { + result = (doublep *)new_doublep(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) { + doublep *arg1 = (doublep *) 0 ; + + arg1 = (doublep *)jarg1; + { + try { + delete_doublep(arg1); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) { + doublep *arg1 = (doublep *) 0 ; + double arg2 ; + + arg1 = (doublep *)jarg1; + arg2 = (double)jarg2; + { + try { + doublep_assign(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) { + double jresult ; + doublep *arg1 = (doublep *) 0 ; + double result; + + arg1 = (doublep *)jarg1; + { + try { + result = (double)doublep_value(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) { + void * jresult ; + doublep *arg1 = (doublep *) 0 ; + double *result = 0 ; + + arg1 = (doublep *)jarg1; + { + try { + result = (double *)doublep_cast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) { + void * jresult ; + double *arg1 = (double *) 0 ; + doublep *result = 0 ; + + arg1 = (double *)jarg1; + { + try { + result = (doublep *)doublep_frompointer(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() { + void * jresult ; + uintp *result = 0 ; + + { + try { + result = (uintp *)new_uintp(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) { + uintp *arg1 = (uintp *) 0 ; + + arg1 = (uintp *)jarg1; + { + try { + delete_uintp(arg1); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) { + uintp *arg1 = (uintp *) 0 ; + unsigned int arg2 ; + + arg1 = (uintp *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + uintp_assign(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) { + unsigned int jresult ; + uintp *arg1 = (uintp *) 0 ; + unsigned int result; + + arg1 = (uintp *)jarg1; + { + try { + result = (unsigned int)uintp_value(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) { + void * jresult ; + uintp *arg1 = (uintp *) 0 ; + unsigned int *result = 0 ; + + arg1 = (uintp *)jarg1; + { + try { + result = (unsigned int *)uintp_cast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) { + void * jresult ; + unsigned int *arg1 = (unsigned int *) 0 ; + uintp *result = 0 ; + + arg1 = (unsigned int *)jarg1; + { + try { + result = (uintp *)uintp_frompointer(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() { + void * jresult ; + ushortp *result = 0 ; + + { + try { + result = (ushortp *)new_ushortp(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) { + ushortp *arg1 = (ushortp *) 0 ; + + arg1 = (ushortp *)jarg1; + { + try { + delete_ushortp(arg1); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) { + ushortp *arg1 = (ushortp *) 0 ; + unsigned short arg2 ; + + arg1 = (ushortp *)jarg1; + arg2 = (unsigned short)jarg2; + { + try { + ushortp_assign(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) { + unsigned short jresult ; + ushortp *arg1 = (ushortp *) 0 ; + unsigned short result; + + arg1 = (ushortp *)jarg1; + { + try { + result = (unsigned short)ushortp_value(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) { + void * jresult ; + ushortp *arg1 = (ushortp *) 0 ; + unsigned short *result = 0 ; + + arg1 = (ushortp *)jarg1; + { + try { + result = (unsigned short *)ushortp_cast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) { + void * jresult ; + unsigned short *arg1 = (unsigned short *) 0 ; + ushortp *result = 0 ; + + arg1 = (unsigned short *)jarg1; + { + try { + result = (ushortp *)ushortp_frompointer(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) { + unsigned int jresult ; + int arg1 ; + unsigned int result; + + arg1 = (int)jarg1; + { + try { + result = (unsigned int)int_to_uint(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) { + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + + arg1 = (char *)jarg1; + arg2 = (char *)jarg2; + { + try { + Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) { + void * jresult ; + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + Dali::DaliException *result = 0 ; + + arg1 = (char *)jarg1; + arg2 = (char *)jarg2; + { + try { + result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) { + Dali::DaliException *arg1 = (Dali::DaliException *) 0 ; + std::string arg2 = std::string(jarg2); + + arg1 = (Dali::DaliException *)jarg1; + { + if (!arg2.empty()) { + ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0'; + } else { + arg1->location = 0; + } + } +} + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) { + char * jresult ; + Dali::DaliException *arg1 = (Dali::DaliException *) 0 ; + char *result = 0 ; + + arg1 = (Dali::DaliException *)jarg1; + result = (char *) ((arg1)->location); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) { + Dali::DaliException *arg1 = (Dali::DaliException *) 0 ; + std::string arg2 = std::string(jarg2); + + arg1 = (Dali::DaliException *)jarg1; + { + if (!arg2.empty()) { + ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0'; + } else { + arg1->condition = 0; + } + } +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) { + char * jresult ; + Dali::DaliException *arg1 = (Dali::DaliException *) 0 ; + char *result = 0 ; + + arg1 = (Dali::DaliException *)jarg1; + result = (char *) ((arg1)->condition); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) { + Dali::DaliException *arg1 = (Dali::DaliException *) 0 ; + + arg1 = (Dali::DaliException *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() { + void * jresult ; + Dali::Uint16Pair *result = 0 ; + + { + try { + result = (Dali::Uint16Pair *)new Dali::Uint16Pair(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) { + void * jresult ; + uint32_t arg1 ; + uint32_t arg2 ; + Dali::Uint16Pair *result = 0 ; + + arg1 = (uint32_t)jarg1; + arg2 = (uint32_t)jarg2; + { + try { + result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) { + void * jresult ; + Dali::Uint16Pair *arg1 = 0 ; + Dali::Uint16Pair *result = 0 ; + + arg1 = (Dali::Uint16Pair *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) { + Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; + uint16_t arg2 ; + + arg1 = (Dali::Uint16Pair *)jarg1; + arg2 = (uint16_t)jarg2; + { + try { + (arg1)->SetWidth(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) { + unsigned short jresult ; + Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; + uint16_t result; + + arg1 = (Dali::Uint16Pair *)jarg1; + { + try { + result = ((Dali::Uint16Pair const *)arg1)->GetWidth(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) { + Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; + uint16_t arg2 ; + + arg1 = (Dali::Uint16Pair *)jarg1; + arg2 = (uint16_t)jarg2; + { + try { + (arg1)->SetHeight(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) { + unsigned short jresult ; + Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; + uint16_t result; + + arg1 = (Dali::Uint16Pair *)jarg1; + { + try { + result = ((Dali::Uint16Pair const *)arg1)->GetHeight(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) { + Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; + uint16_t arg2 ; + + arg1 = (Dali::Uint16Pair *)jarg1; + arg2 = (uint16_t)jarg2; + { + try { + (arg1)->SetX(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) { + unsigned short jresult ; + Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; + uint16_t result; + + arg1 = (Dali::Uint16Pair *)jarg1; + { + try { + result = ((Dali::Uint16Pair const *)arg1)->GetX(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) { + Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; + uint16_t arg2 ; + + arg1 = (Dali::Uint16Pair *)jarg1; + arg2 = (uint16_t)jarg2; + { + try { + (arg1)->SetY(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) { + unsigned short jresult ; + Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; + uint16_t result; + + arg1 = (Dali::Uint16Pair *)jarg1; + { + try { + result = ((Dali::Uint16Pair const *)arg1)->GetY(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; + Dali::Uint16Pair *arg2 = 0 ; + Dali::Uint16Pair *result = 0 ; + + arg1 = (Dali::Uint16Pair *)jarg1; + arg2 = (Dali::Uint16Pair *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; + Dali::Uint16Pair *arg2 = 0 ; + bool result; + + arg1 = (Dali::Uint16Pair *)jarg1; + arg2 = (Dali::Uint16Pair *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; + Dali::Uint16Pair *arg2 = 0 ; + bool result; + + arg1 = (Dali::Uint16Pair *)jarg1; + arg2 = (Dali::Uint16Pair *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; + Dali::Uint16Pair *arg2 = 0 ; + bool result; + + arg1 = (Dali::Uint16Pair *)jarg1; + arg2 = (Dali::Uint16Pair *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; + Dali::Uint16Pair *arg2 = 0 ; + bool result; + + arg1 = (Dali::Uint16Pair *)jarg1; + arg2 = (Dali::Uint16Pair *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) { + Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; + + arg1 = (Dali::Uint16Pair *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Int32Pair__SWIG_0() { + void * jresult ; + Dali::Int32Pair *result = 0 ; + + { + try { + result = (Dali::Int32Pair *)new Dali::Int32Pair(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Int32Pair__SWIG_1(int32_t x, int32_t y) { + void * jresult ; + Dali::Int32Pair *result = 0 ; + + { + try { + result = (Dali::Int32Pair *)new Dali::Int32Pair(x,y); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Int32Pair_SetX(void * int32Pair, int32_t x) { + Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ; + + { + try { + (pInt32Pair)->SetX(x); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Int32Pair_GetX(void * int32Pair) { + int result ; + Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair); + + { + try { + result = ((Dali::Int32Pair const *)pInt32Pair)->GetX(); + } CALL_CATCH_EXCEPTION(0); + } + + return result; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Int32Pair_SetY(void * int32Pair, int32_t y) { + Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ; + + { + try { + (pInt32Pair)->SetY(y); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Int32Pair_GetY(void * int32Pair) { + Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ; + int result; + + { + try { + result = ((Dali::Int32Pair const *)pInt32Pair)->GetY(); + } CALL_CATCH_EXCEPTION(0); + } + + return result; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Int32Pair(void * int32Pair) { + Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ; + + { + try { + delete pInt32Pair; + } CALL_CATCH_EXCEPTION(); + } + +} + + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() { + void * jresult ; + Dali::Degree *result = 0 ; + + { + try { + result = (Dali::Degree *)new Dali::Degree(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) { + void * jresult ; + float arg1 ; + Dali::Degree *result = 0 ; + + arg1 = (float)jarg1; + { + try { + result = (Dali::Degree *)new Dali::Degree(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) { + void * jresult ; + Dali::Radian arg1 ; + Dali::Radian *argp1 ; + Dali::Degree *result = 0 ; + + argp1 = (Dali::Radian *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg1 = *argp1; + { + try { + result = (Dali::Degree *)new Dali::Degree(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) { + Dali::Degree *arg1 = (Dali::Degree *) 0 ; + float arg2 ; + + arg1 = (Dali::Degree *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->degree = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) { + float jresult ; + Dali::Degree *arg1 = (Dali::Degree *) 0 ; + float result; + + arg1 = (Dali::Degree *)jarg1; + result = (float) ((arg1)->degree); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) { + Dali::Degree *arg1 = (Dali::Degree *) 0 ; + + arg1 = (Dali::Degree *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() { + void * jresult ; + Dali::Radian *result = 0 ; + + result = (Dali::Radian *)&Dali::ANGLE_360; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() { + void * jresult ; + Dali::Radian *result = 0 ; + + result = (Dali::Radian *)&Dali::ANGLE_315; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() { + void * jresult ; + Dali::Radian *result = 0 ; + + result = (Dali::Radian *)&Dali::ANGLE_270; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() { + void * jresult ; + Dali::Radian *result = 0 ; + + result = (Dali::Radian *)&Dali::ANGLE_225; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() { + void * jresult ; + Dali::Radian *result = 0 ; + + result = (Dali::Radian *)&Dali::ANGLE_180; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() { + void * jresult ; + Dali::Radian *result = 0 ; + + result = (Dali::Radian *)&Dali::ANGLE_135; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() { + void * jresult ; + Dali::Radian *result = 0 ; + + result = (Dali::Radian *)&Dali::ANGLE_120; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() { + void * jresult ; + Dali::Radian *result = 0 ; + + result = (Dali::Radian *)&Dali::ANGLE_90; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() { + void * jresult ; + Dali::Radian *result = 0 ; + + result = (Dali::Radian *)&Dali::ANGLE_60; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() { + void * jresult ; + Dali::Radian *result = 0 ; + + result = (Dali::Radian *)&Dali::ANGLE_45; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() { + void * jresult ; + Dali::Radian *result = 0 ; + + result = (Dali::Radian *)&Dali::ANGLE_30; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() { + void * jresult ; + Dali::Radian *result = 0 ; + + result = (Dali::Radian *)&Dali::ANGLE_0; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Degree *arg1 = 0 ; + Dali::Degree *arg2 = 0 ; + bool result; + + arg1 = (Dali::Degree *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0); + return 0; + } + arg2 = (Dali::Degree *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0); + return 0; + } + { + try { + result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Degree *arg1 = 0 ; + Dali::Degree *arg2 = 0 ; + bool result; + + arg1 = (Dali::Degree *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0); + return 0; + } + arg2 = (Dali::Degree *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0); + return 0; + } + { + try { + result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) { + void * jresult ; + Dali::Degree arg1 ; + float arg2 ; + float arg3 ; + Dali::Degree *argp1 ; + Dali::Degree result; + + argp1 = (Dali::Degree *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); + return 0; + } + arg1 = *argp1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + { + try { + result = Dali::Clamp(arg1,arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Degree((const Dali::Degree &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() { + void * jresult ; + Dali::Radian *result = 0 ; + + { + try { + result = (Dali::Radian *)new Dali::Radian(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) { + void * jresult ; + float arg1 ; + Dali::Radian *result = 0 ; + + arg1 = (float)jarg1; + { + try { + result = (Dali::Radian *)new Dali::Radian(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) { + void * jresult ; + Dali::Degree arg1 ; + Dali::Degree *argp1 ; + Dali::Radian *result = 0 ; + + argp1 = (Dali::Degree *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); + return 0; + } + arg1 = *argp1; + { + try { + result = (Dali::Radian *)new Dali::Radian(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) { + void * jresult ; + Dali::Radian *arg1 = (Dali::Radian *) 0 ; + float arg2 ; + Dali::Radian *result = 0 ; + + arg1 = (Dali::Radian *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (Dali::Radian *) &(arg1)->operator =(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Radian *arg1 = (Dali::Radian *) 0 ; + Dali::Degree arg2 ; + Dali::Degree *argp2 ; + Dali::Radian *result = 0 ; + + arg1 = (Dali::Radian *)jarg1; + argp2 = (Dali::Degree *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (Dali::Radian *) &(arg1)->operator =(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) { + float jresult ; + Dali::Radian *arg1 = (Dali::Radian *) 0 ; + float result; + + arg1 = (Dali::Radian *)jarg1; + { + try { + result = (float)((Dali::Radian const *)arg1)->operator float(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) { + Dali::Radian *arg1 = (Dali::Radian *) 0 ; + float arg2 ; + + arg1 = (Dali::Radian *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->radian = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) { + float jresult ; + Dali::Radian *arg1 = (Dali::Radian *) 0 ; + float result; + + arg1 = (Dali::Radian *)jarg1; + result = (float) ((arg1)->radian); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) { + Dali::Radian *arg1 = (Dali::Radian *) 0 ; + + arg1 = (Dali::Radian *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Radian arg1 ; + Dali::Radian arg2 ; + Dali::Radian *argp1 ; + Dali::Radian *argp2 ; + bool result; + + argp1 = (Dali::Radian *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg1 = *argp1; + argp2 = (Dali::Radian *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)Dali::operator ==(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Radian arg1 ; + Dali::Radian arg2 ; + Dali::Radian *argp1 ; + Dali::Radian *argp2 ; + bool result; + + argp1 = (Dali::Radian *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg1 = *argp1; + argp2 = (Dali::Radian *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)Dali::operator !=(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Radian arg1 ; + Dali::Degree arg2 ; + Dali::Radian *argp1 ; + Dali::Degree *argp2 ; + bool result; + + argp1 = (Dali::Radian *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg1 = *argp1; + argp2 = (Dali::Degree *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)Dali::operator ==(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Radian arg1 ; + Dali::Degree arg2 ; + Dali::Radian *argp1 ; + Dali::Degree *argp2 ; + bool result; + + argp1 = (Dali::Radian *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg1 = *argp1; + argp2 = (Dali::Degree *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)Dali::operator !=(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Degree arg1 ; + Dali::Radian arg2 ; + Dali::Degree *argp1 ; + Dali::Radian *argp2 ; + bool result; + + argp1 = (Dali::Degree *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); + return 0; + } + arg1 = *argp1; + argp2 = (Dali::Radian *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)Dali::operator ==(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Degree arg1 ; + Dali::Radian arg2 ; + Dali::Degree *argp1 ; + Dali::Radian *argp2 ; + bool result; + + argp1 = (Dali::Degree *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); + return 0; + } + arg1 = *argp1; + argp2 = (Dali::Radian *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)Dali::operator !=(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Radian arg1 ; + Dali::Radian arg2 ; + Dali::Radian *argp1 ; + Dali::Radian *argp2 ; + bool result; + + argp1 = (Dali::Radian *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg1 = *argp1; + argp2 = (Dali::Radian *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)Dali::operator >(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Radian arg1 ; + Dali::Degree arg2 ; + Dali::Radian *argp1 ; + Dali::Degree *argp2 ; + bool result; + + argp1 = (Dali::Radian *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg1 = *argp1; + argp2 = (Dali::Degree *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)Dali::operator >(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Degree arg1 ; + Dali::Radian arg2 ; + Dali::Degree *argp1 ; + Dali::Radian *argp2 ; + bool result; + + argp1 = (Dali::Degree *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); + return 0; + } + arg1 = *argp1; + argp2 = (Dali::Radian *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)Dali::operator >(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Radian arg1 ; + Dali::Radian arg2 ; + Dali::Radian *argp1 ; + Dali::Radian *argp2 ; + bool result; + + argp1 = (Dali::Radian *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg1 = *argp1; + argp2 = (Dali::Radian *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)Dali::operator <(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Radian arg1 ; + Dali::Degree arg2 ; + Dali::Radian *argp1 ; + Dali::Degree *argp2 ; + bool result; + + argp1 = (Dali::Radian *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg1 = *argp1; + argp2 = (Dali::Degree *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)Dali::operator <(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Degree arg1 ; + Dali::Radian arg2 ; + Dali::Degree *argp1 ; + Dali::Radian *argp2 ; + bool result; + + argp1 = (Dali::Degree *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); + return 0; + } + arg1 = *argp1; + argp2 = (Dali::Radian *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)Dali::operator <(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) { + void * jresult ; + Dali::Radian arg1 ; + float arg2 ; + Dali::Radian *argp1 ; + Dali::Radian result; + + argp1 = (Dali::Radian *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg1 = *argp1; + arg2 = (float)jarg2; + { + try { + result = Dali::operator *(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Radian((const Dali::Radian &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) { + void * jresult ; + Dali::Radian arg1 ; + Dali::Radian *argp1 ; + Dali::Radian result; + + argp1 = (Dali::Radian *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg1 = *argp1; + { + try { + result = Dali::operator -(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Radian((const Dali::Radian &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) { + void * jresult ; + Dali::Radian arg1 ; + float arg2 ; + float arg3 ; + Dali::Radian *argp1 ; + Dali::Radian result; + + argp1 = (Dali::Radian *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg1 = *argp1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + { + try { + result = Dali::Clamp(arg1,arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Radian((const Dali::Radian &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() { + void * jresult ; + Dali::Matrix *result = 0 ; + + { + try { + result = (Dali::Matrix *)new Dali::Matrix(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(bool jarg1) { + void * jresult ; + bool arg1 ; + Dali::Matrix *result = 0 ; + + arg1 = jarg1 ? true : false; + { + try { + result = (Dali::Matrix *)new Dali::Matrix(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) { + void * jresult ; + float *arg1 = (float *) 0 ; + Dali::Matrix *result = 0 ; + + arg1 = jarg1; + { + try { + result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) { + void * jresult ; + Dali::Quaternion *arg1 = 0 ; + Dali::Matrix *result = 0 ; + + arg1 = (Dali::Quaternion *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) { + void * jresult ; + Dali::Matrix *arg1 = 0 ; + Dali::Matrix *result = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Matrix *arg2 = 0 ; + Dali::Matrix *result = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + arg2 = (Dali::Matrix *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() { + void * jresult ; + Dali::Matrix *result = 0 ; + + result = (Dali::Matrix *)&Dali::Matrix::IDENTITY; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) { + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + + arg1 = (Dali::Matrix *)jarg1; + { + try { + (arg1)->SetIdentity(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) { + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Vector3 *arg2 = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) { + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Matrix *arg2 = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + arg2 = (Dali::Matrix *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0); + return ; + } + { + try { + ((Dali::Matrix const *)arg1)->InvertTransform(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) { + bool jresult ; + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + bool result; + + arg1 = (Dali::Matrix *)jarg1; + { + try { + result = (bool)(arg1)->Invert(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) { + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + + arg1 = (Dali::Matrix *)jarg1; + { + try { + (arg1)->Transpose(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) { + void * jresult ; + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Vector3 result; + + arg1 = (Dali::Matrix *)jarg1; + { + try { + result = ((Dali::Matrix const *)arg1)->GetXAxis(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) { + void * jresult ; + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Vector3 result; + + arg1 = (Dali::Matrix *)jarg1; + { + try { + result = ((Dali::Matrix const *)arg1)->GetYAxis(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) { + void * jresult ; + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Vector3 result; + + arg1 = (Dali::Matrix *)jarg1; + { + try { + result = ((Dali::Matrix const *)arg1)->GetZAxis(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) { + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Vector3 *arg2 = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetXAxis((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) { + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Vector3 *arg2 = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetYAxis((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) { + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Vector3 *arg2 = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetZAxis((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) { + void * jresult ; + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Vector4 *result = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + { + try { + result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) { + void * jresult ; + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Vector3 *result = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + { + try { + result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) { + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Vector4 *arg2 = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetTranslation((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) { + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Vector3 *arg2 = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetTranslation((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) { + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + + arg1 = (Dali::Matrix *)jarg1; + { + try { + (arg1)->OrthoNormalize(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) { + void * jresult ; + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + float *result = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + { + try { + result = (float *)((Dali::Matrix const *)arg1)->AsFloat(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { + Dali::Matrix *arg1 = 0 ; + Dali::Matrix *arg2 = 0 ; + Dali::Matrix *arg3 = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0); + return ; + } + arg2 = (Dali::Matrix *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); + return ; + } + arg3 = (Dali::Matrix *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); + return ; + } + { + try { + Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) { + Dali::Matrix *arg1 = 0 ; + Dali::Matrix *arg2 = 0 ; + Dali::Quaternion *arg3 = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0); + return ; + } + arg2 = (Dali::Matrix *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); + return ; + } + arg3 = (Dali::Quaternion *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return ; + } + { + try { + Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Vector4 *arg2 = 0 ; + Dali::Vector4 result; + + arg1 = (Dali::Matrix *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); + return 0; + } + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_3(void * nuiMatrixLhs, void * nuiMatrixRhs) { + void * jresult ; + Dali::Matrix *lhsPtr = (Dali::Matrix *) 0 ; + Dali::Matrix *rhsPtr = (Dali::Matrix *) 0 ; + Dali::Matrix result(false); + + lhsPtr = (Dali::Matrix *)nuiMatrixLhs; + if (!lhsPtr) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0); + return 0; + } + rhsPtr = (Dali::Matrix *)nuiMatrixRhs; + if (!rhsPtr) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0); + return 0; + } + { + try { + result = ((Dali::Matrix const *)lhsPtr)->operator *((Dali::Matrix const &)*rhsPtr); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Matrix((const Dali::Matrix &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_4(void * nuiMatrixLhs, void * nuiMatrixRhs) { + // Faster mulitply operation without memcpy + + Dali::Matrix *jresult = (Dali::Matrix *)0; + Dali::Matrix *lhsPtr = (Dali::Matrix *)0; + Dali::Matrix *rhsPtr = (Dali::Matrix *)0; + + lhsPtr = (Dali::Matrix *)nuiMatrixLhs; + if (!lhsPtr) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0); + return 0; + } + rhsPtr = (Dali::Matrix *)nuiMatrixRhs; + if (!rhsPtr) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0); + return 0; + } + { + try { + jresult = new Dali::Matrix(false); + Dali::Matrix::Multiply((Dali::Matrix &)*jresult,(Dali::Matrix const &)*rhsPtr,(Dali::Matrix const &)*lhsPtr); + } CALL_CATCH_EXCEPTION(0); + } + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_MultiplyAssign(void * nuiMatrix, void * nuiMatrixRhs) { + void * jresult = 0; + Dali::Matrix *lhsPtr = (Dali::Matrix *) 0 ; + Dali::Matrix *rhsPtr = (Dali::Matrix *) 0 ; + Dali::Matrix *retPtr = (Dali::Matrix *) 0 ; + + lhsPtr = (Dali::Matrix *)nuiMatrix; + if (!lhsPtr) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0); + return 0; + } + rhsPtr = (Dali::Matrix *)nuiMatrixRhs; + if (!rhsPtr) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0); + return 0; + } + { + try { + retPtr = (Dali::Matrix *) &(lhsPtr)->operator *=((Dali::Matrix const &)*rhsPtr); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)retPtr; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Matrix *arg2 = 0 ; + bool result; + + arg1 = (Dali::Matrix *)jarg1; + arg2 = (Dali::Matrix *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Matrix *arg2 = 0 ; + bool result; + + arg1 = (Dali::Matrix *)jarg1; + arg2 = (Dali::Matrix *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix_ValueOfIndex__SWIG_0(void * nuiMatrix, unsigned int index) { + float jresult ; + Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ; + + pMatrix = (Dali::Matrix *)nuiMatrix; + if (!pMatrix) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); + return 0; + } + if (index >= 16) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 16.)", 0); + return 0; + } + { + try { + const float* temp = ((Dali::Matrix const *)pMatrix)->AsFloat(); + jresult = temp[index]; + } CALL_CATCH_EXCEPTION(0); + } + return jresult; +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix_ValueOfIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn) { + float jresult ; + Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ; + + pMatrix = (Dali::Matrix *)nuiMatrix; + if (!pMatrix) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); + return 0; + } + if (indexRow >= 4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 4.)", 0); + return 0; + } + if (indexColumn >= 4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 4.)", 0); + return 0; + } + { + try { + const float* temp = ((Dali::Matrix const *)pMatrix)->AsFloat(); + jresult = temp[(indexColumn << 2) | indexRow]; + } CALL_CATCH_EXCEPTION(0); + } + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetValueAtIndex__SWIG_0(void * nuiMatrix, unsigned int index, float value) { + Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ; + + pMatrix = (Dali::Matrix *)nuiMatrix; + if (!pMatrix) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); + return; + } + if (index >= 16) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 16.)", 0); + return; + } + { + try { + float* temp = ((Dali::Matrix *)pMatrix)->AsFloat(); + temp[index] = value; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetValueAtIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn, float value) { + Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ; + + pMatrix = (Dali::Matrix *)nuiMatrix; + if (!pMatrix) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); + return; + } + if (indexRow >= 4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 4.)", 0); + return; + } + if (indexColumn >= 4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 4.)", 0); + return; + } + { + try { + float* temp = ((Dali::Matrix *)pMatrix)->AsFloat(); + temp[(indexColumn << 2) | indexRow] = value; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Quaternion *arg3 = 0 ; + Dali::Vector3 *arg4 = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + arg3 = (Dali::Quaternion *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return ; + } + arg4 = (Dali::Vector3 *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Quaternion *arg3 = 0 ; + Dali::Vector3 *arg4 = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + arg3 = (Dali::Quaternion *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return ; + } + arg4 = (Dali::Vector3 *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) { + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Vector3 *arg3 = 0 ; + Dali::Vector3 *arg4 = 0 ; + Dali::Vector3 *arg5 = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + arg3 = (Dali::Vector3 *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + arg4 = (Dali::Vector3 *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + arg5 = (Dali::Vector3 *)jarg5; + if (!arg5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Quaternion *arg3 = 0 ; + Dali::Vector3 *arg4 = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); + return ; + } + arg3 = (Dali::Quaternion *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0); + return ; + } + arg4 = (Dali::Vector3 *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); + return ; + } + { + try { + ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) { + Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; + + arg1 = (Dali::Matrix *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() { + void * jresult ; + Dali::Matrix3 *result = 0 ; + + result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() { + void * jresult ; + Dali::Matrix3 *result = 0 ; + + { + try { + result = (Dali::Matrix3 *)new Dali::Matrix3(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Matrix3 *arg1 = 0 ; + Dali::Matrix3 *result = 0 ; + + arg1 = (Dali::Matrix3 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) { + void * jresult ; + Dali::Matrix *arg1 = 0 ; + Dali::Matrix3 *result = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) { + void * jresult ; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + float arg9 ; + Dali::Matrix3 *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + arg5 = (float)jarg5; + arg6 = (float)jarg6; + arg7 = (float)jarg7; + arg8 = (float)jarg8; + arg9 = (float)jarg9; + { + try { + result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; + Dali::Matrix3 *arg2 = 0 ; + Dali::Matrix3 *result = 0 ; + + arg1 = (Dali::Matrix3 *)jarg1; + arg2 = (Dali::Matrix3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; + Dali::Matrix *arg2 = 0 ; + Dali::Matrix3 *result = 0 ; + + arg1 = (Dali::Matrix3 *)jarg1; + arg2 = (Dali::Matrix *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; + Dali::Matrix3 *arg2 = 0 ; + bool result; + + arg1 = (Dali::Matrix3 *)jarg1; + arg2 = (Dali::Matrix3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; + Dali::Matrix3 *arg2 = 0 ; + bool result; + + arg1 = (Dali::Matrix3 *)jarg1; + arg2 = (Dali::Matrix3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_ValueOfIndex__SWIG_0(void * nuiMatrix, unsigned int index) { + float jresult ; + Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ; + + pMatrix = (Dali::Matrix3 *)nuiMatrix; + if (!pMatrix) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); + return 0; + } + if (index >= 9) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 9.)", 0); + return 0; + } + { + try { + const float* temp = ((Dali::Matrix3 const *)pMatrix)->AsFloat(); + jresult = temp[index]; + } CALL_CATCH_EXCEPTION(0); + } + return jresult; +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_ValueOfIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn) { + float jresult ; + Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ; + + pMatrix = (Dali::Matrix3 *)nuiMatrix; + if (!pMatrix) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); + return 0; + } + if (indexRow >= 3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 3.)", 0); + return 0; + } + if (indexColumn >= 3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 3.)", 0); + return 0; + } + { + try { + const float* temp = ((Dali::Matrix3 const *)pMatrix)->AsFloat(); + jresult = temp[indexColumn * 3 + indexRow]; + } CALL_CATCH_EXCEPTION(0); + } + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetValueAtIndex__SWIG_0(void * nuiMatrix, unsigned int index, float value) { + Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ; + + pMatrix = (Dali::Matrix3 *)nuiMatrix; + if (!pMatrix) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); + return; + } + if (index >= 9) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 9.)", 0); + return; + } + { + try { + float* temp = ((Dali::Matrix3 *)pMatrix)->AsFloat(); + temp[index] = value; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetValueAtIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn, float value) { + Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ; + + pMatrix = (Dali::Matrix3 *)nuiMatrix; + if (!pMatrix) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); + return; + } + if (indexRow >= 3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 3.)", 0); + return; + } + if (indexColumn >= 3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 3.)", 0); + return; + } + { + try { + float* temp = ((Dali::Matrix3 *)pMatrix)->AsFloat(); + temp[indexColumn * 3 + indexRow] = value; + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) { + Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; + + arg1 = (Dali::Matrix3 *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) { + Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; + + arg1 = (Dali::Matrix3 *)jarg1; + { + try { + (arg1)->SetIdentity(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) { + void * jresult ; + Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; + float *result = 0 ; + + arg1 = (Dali::Matrix3 *)jarg1; + { + try { + result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) { + bool jresult ; + Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; + bool result; + + arg1 = (Dali::Matrix3 *)jarg1; + { + try { + result = (bool)(arg1)->Invert(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) { + bool jresult ; + Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; + bool result; + + arg1 = (Dali::Matrix3 *)jarg1; + { + try { + result = (bool)(arg1)->Transpose(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) { + Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; + float arg2 ; + + arg1 = (Dali::Matrix3 *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->Scale(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) { + float jresult ; + Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; + float result; + + arg1 = (Dali::Matrix3 *)jarg1; + { + try { + result = (float)((Dali::Matrix3 const *)arg1)->Magnitude(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) { + bool jresult ; + Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; + bool result; + + arg1 = (Dali::Matrix3 *)jarg1; + { + try { + result = (bool)(arg1)->ScaledInverseTranspose(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) { + Dali::Matrix3 *arg1 = 0 ; + Dali::Matrix3 *arg2 = 0 ; + Dali::Matrix3 *arg3 = 0 ; + + arg1 = (Dali::Matrix3 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0); + return ; + } + arg2 = (Dali::Matrix3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); + return ; + } + arg3 = (Dali::Matrix3 *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); + return ; + } + { + try { + Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_1(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Matrix3 *arg1 = 0 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Vector3 result; + + arg1 = (Dali::Matrix3 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); + return 0; + } + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = ((Dali::Matrix3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_2(void * nuiMatrix3Lhs, void * nuiMatrix3Rhs) { + void * jresult ; + Dali::Matrix3 *lhsPtr = 0 ; + Dali::Matrix3 *rhsPtr = 0 ; + Dali::Matrix3 result; + + lhsPtr = (Dali::Matrix3 *)nuiMatrix3Lhs; + if (!lhsPtr) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0); + return 0; + } + rhsPtr = (Dali::Matrix3 *)nuiMatrix3Rhs; + if (!rhsPtr) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0); + return 0; + } + { + try { + result = ((Dali::Matrix3 const *)lhsPtr)->operator *((Dali::Matrix3 const &)*rhsPtr); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Matrix3((const Dali::Matrix3 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_3(void * nuiMatrix3Lhs, void * nuiMatrix3Rhs) { + // Faster mulitply operation without memcpy + + Dali::Matrix3 *jresult = 0; + Dali::Matrix3 *lhsPtr = 0; + Dali::Matrix3 *rhsPtr = 0; + + lhsPtr = (Dali::Matrix3 *)nuiMatrix3Lhs; + if (!lhsPtr) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0); + return 0; + } + rhsPtr = (Dali::Matrix3 *)nuiMatrix3Rhs; + if (!rhsPtr) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0); + return 0; + } + { + try { + jresult = new Dali::Matrix3(); + Dali::Matrix3::Multiply((Dali::Matrix3 &)*jresult,(Dali::Matrix3 const &)*rhsPtr,(Dali::Matrix3 const &)*lhsPtr); + } CALL_CATCH_EXCEPTION(0); + } + + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_MultiplyAssign(void * nuiMatrix, void * nuiMatrixRhs) { + void * jresult = 0; + Dali::Matrix3 *lhsPtr = (Dali::Matrix3 *) 0 ; + Dali::Matrix3 *rhsPtr = (Dali::Matrix3 *) 0 ; + Dali::Matrix3 *retPtr = (Dali::Matrix3 *) 0 ; + + lhsPtr = (Dali::Matrix3 *)nuiMatrix; + if (!lhsPtr) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0); + return 0; + } + rhsPtr = (Dali::Matrix3 *)nuiMatrixRhs; + if (!rhsPtr) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0); + return 0; + } + { + try { + retPtr = (Dali::Matrix3 *) &(lhsPtr)->operator *=((Dali::Matrix3 const &)*rhsPtr); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)retPtr; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) { + float jresult ; + float arg1 ; + float arg2 ; + float result; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + { + try { + result = (float)Dali::Random::Range(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() { + void * jresult ; + Dali::Vector4 result; + + { + try { + result = Dali::Random::Axis(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() { + void * jresult ; + Dali::AngleAxis *result = 0 ; + + { + try { + result = (Dali::AngleAxis *)new Dali::AngleAxis(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Radian arg1 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Radian *argp1 ; + Dali::AngleAxis *result = 0 ; + + argp1 = (Dali::Radian *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg1 = *argp1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) { + Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ; + Dali::Radian *arg2 = (Dali::Radian *) 0 ; + + arg1 = (Dali::AngleAxis *)jarg1; + arg2 = (Dali::Radian *)jarg2; + if (arg1) (arg1)->angle = *arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) { + void * jresult ; + Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ; + Dali::Radian *result = 0 ; + + arg1 = (Dali::AngleAxis *)jarg1; + result = (Dali::Radian *)& ((arg1)->angle); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) { + Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ; + Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ; + + arg1 = (Dali::AngleAxis *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (arg1) (arg1)->axis = *arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) { + void * jresult ; + Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ; + Dali::Vector3 *result = 0 ; + + arg1 = (Dali::AngleAxis *)jarg1; + result = (Dali::Vector3 *)& ((arg1)->axis); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) { + Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ; + + arg1 = (Dali::AngleAxis *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) { + bool jresult ; + Dali::AngleAxis *arg1 = 0 ; + Dali::AngleAxis *arg2 = 0 ; + bool result; + + arg1 = (Dali::AngleAxis *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0); + return 0; + } + arg2 = (Dali::AngleAxis *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0); + return 0; + } + { + try { + result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) { + unsigned int jresult ; + unsigned int arg1 ; + unsigned int result; + + arg1 = (unsigned int)jarg1; + { + try { + result = (unsigned int)Dali::NextPowerOfTwo(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) { + bool jresult ; + unsigned int arg1 ; + bool result; + + arg1 = (unsigned int)jarg1; + { + try { + result = (bool)Dali::IsPowerOfTwo(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) { + float jresult ; + float arg1 ; + float arg2 ; + float result; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + { + try { + result = (float)Dali::GetRangedEpsilon(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) { + bool jresult ; + float arg1 ; + bool result; + + arg1 = (float)jarg1; + { + try { + result = (bool)Dali::EqualsZero(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) { + bool jresult ; + float arg1 ; + float arg2 ; + bool result; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + { + try { + result = (bool)Dali::Equals(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) { + bool jresult ; + float arg1 ; + float arg2 ; + float arg3 ; + bool result; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + { + try { + result = (bool)Dali::Equals(arg1,arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) { + float jresult ; + float arg1 ; + int arg2 ; + float result; + + arg1 = (float)jarg1; + arg2 = (int)jarg2; + { + try { + result = (float)Dali::Round(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) { + float jresult ; + float arg1 ; + float arg2 ; + float arg3 ; + float result; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + { + try { + result = (float)Dali::WrapInDomain(arg1,arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) { + float jresult ; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float result; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + { + try { + result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) { + void * jresult ; + Dali::Handle *arg1 = 0 ; + Dali::Property::Index arg2 ; + Dali::Property *result = 0 ; + + arg1 = (Dali::Handle *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); + return 0; + } + arg2 = (Dali::Property::Index)jarg2; + { + try { + result = (Dali::Property *)new Dali::Property(*arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) { + void * jresult ; + Dali::Handle *arg1 = 0 ; + Dali::Property::Index arg2 ; + int arg3 ; + Dali::Property *result = 0 ; + + arg1 = (Dali::Handle *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); + return 0; + } + arg2 = (Dali::Property::Index)jarg2; + arg3 = (int)jarg3; + { + try { + result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) { + void * jresult ; + Dali::Handle *arg1 = 0 ; + std::string *arg2 = 0 ; + Dali::Property *result = 0 ; + + arg1 = (Dali::Handle *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); + return 0; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) { + void * jresult ; + Dali::Handle *arg1 = 0 ; + std::string *arg2 = 0 ; + int arg3 ; + Dali::Property *result = 0 ; + + arg1 = (Dali::Handle *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); + return 0; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (int)jarg3; + { + try { + result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) { + Dali::Property *arg1 = (Dali::Property *) 0 ; + + arg1 = (Dali::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) { + Dali::Property *arg1 = (Dali::Property *) 0 ; + Dali::Handle *arg2 = 0 ; + + arg1 = (Dali::Property *)jarg1; + arg2 = (Dali::Handle *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); + return ; + } + if (arg1) (arg1)->object = *arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) { + void * jresult ; + Dali::Property *arg1 = (Dali::Property *) 0 ; + Dali::Handle *result = 0 ; + + arg1 = (Dali::Property *)jarg1; + result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) { + Dali::Property *arg1 = (Dali::Property *) 0 ; + Dali::Property::Index arg2 ; + + arg1 = (Dali::Property *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + if (arg1) (arg1)->propertyIndex = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) { + int jresult ; + Dali::Property *arg1 = (Dali::Property *) 0 ; + Dali::Property::Index result; + + arg1 = (Dali::Property *)jarg1; + result = (Dali::Property::Index) ((arg1)->propertyIndex); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) { + Dali::Property *arg1 = (Dali::Property *) 0 ; + int arg2 ; + + arg1 = (Dali::Property *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->componentIndex = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) { + int jresult ; + Dali::Property *arg1 = (Dali::Property *) 0 ; + int result; + + arg1 = (Dali::Property *)jarg1; + result = (int) ((arg1)->componentIndex); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() { + void * jresult ; + Dali::Property::Array *result = 0 ; + + { + try { + result = (Dali::Property::Array *)new Dali::Property::Array(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Property::Array *arg1 = 0 ; + Dali::Property::Array *result = 0 ; + + arg1 = (Dali::Property::Array *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) { + Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; + + arg1 = (Dali::Property::Array *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) { + unsigned long jresult ; + Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; + Dali::Property::Array::SizeType result; + + arg1 = (Dali::Property::Array *)jarg1; + { + try { + result = ((Dali::Property::Array const *)arg1)->Size(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) { + unsigned long jresult ; + Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; + Dali::Property::Array::SizeType result; + + arg1 = (Dali::Property::Array *)jarg1; + { + try { + result = ((Dali::Property::Array const *)arg1)->Count(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) { + bool jresult ; + Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; + bool result; + + arg1 = (Dali::Property::Array *)jarg1; + { + try { + result = (bool)((Dali::Property::Array const *)arg1)->Empty(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) { + Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; + + arg1 = (Dali::Property::Array *)jarg1; + { + try { + (arg1)->Clear(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) { + Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; + Dali::Property::Array::SizeType arg2 ; + + arg1 = (Dali::Property::Array *)jarg1; + arg2 = (Dali::Property::Array::SizeType)jarg2; + { + try { + (arg1)->Reserve(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) { + Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; + Dali::Property::Array::SizeType arg2 ; + + arg1 = (Dali::Property::Array *)jarg1; + arg2 = (Dali::Property::Array::SizeType)jarg2; + { + try { + (arg1)->Resize(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) { + unsigned long jresult ; + Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; + Dali::Property::Array::SizeType result; + + arg1 = (Dali::Property::Array *)jarg1; + { + try { + result = (arg1)->Capacity(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) { + Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; + Dali::Property::Value *arg2 = 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 ; + } + { + try { + (arg1)->PushBack((Dali::Property::Value const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +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); + } CALL_CATCH_EXCEPTION(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 ; + Dali::Property::Array::SizeType arg2 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Property::Array *)jarg1; + arg2 = (Dali::Property::Array::SizeType)jarg2; + { + try { + result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; + Dali::Property::Array::SizeType arg2 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Property::Array *)jarg1; + arg2 = (Dali::Property::Array::SizeType)jarg2; + { + try { + result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; + Dali::Property::Array *arg2 = 0 ; + Dali::Property::Array *result = 0 ; + + arg1 = (Dali::Property::Array *)jarg1; + arg2 = (Dali::Property::Array *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) { + Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; + enum Dali::Property::Key::Type arg2 ; + + arg1 = (Dali::Property::Key *)jarg1; + arg2 = (enum Dali::Property::Key::Type)jarg2; + if (arg1) (arg1)->type = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) { + int jresult ; + Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; + enum Dali::Property::Key::Type result; + + arg1 = (Dali::Property::Key *)jarg1; + result = (enum Dali::Property::Key::Type) ((arg1)->type); + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) { + Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; + Dali::Property::Index arg2 ; + + arg1 = (Dali::Property::Key *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + if (arg1) (arg1)->indexKey = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) { + int jresult ; + Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; + Dali::Property::Index result; + + arg1 = (Dali::Property::Key *)jarg1; + result = (Dali::Property::Index) ((arg1)->indexKey); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) { + Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::Property::Key *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + if (arg1) (arg1)->stringKey = *arg2; + + //argout typemap for const std::string& + +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) { + char * jresult ; + Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; + std::string *result = 0 ; + + arg1 = (Dali::Property::Key *)jarg1; + result = (std::string *) & ((arg1)->stringKey); + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::Property::Key *result = 0 ; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + { + try { + result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) { + void * jresult ; + Dali::Property::Index arg1 ; + Dali::Property::Key *result = 0 ; + + arg1 = (Dali::Property::Index)jarg1; + { + try { + result = (Dali::Property::Key *)new Dali::Property::Key(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) { + bool jresult ; + Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; + std::string *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Key *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + result = (bool)(arg1)->operator ==((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) { + bool jresult ; + Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; + Dali::Property::Index arg2 ; + bool result; + + arg1 = (Dali::Property::Key *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + { + try { + result = (bool)(arg1)->operator ==(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; + Dali::Property::Key *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Key *)jarg1; + arg2 = (Dali::Property::Key *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0); + return 0; + } + { + try { + result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) { + bool jresult ; + Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; + std::string *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Key *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + result = (bool)(arg1)->operator !=((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) { + bool jresult ; + Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; + Dali::Property::Index arg2 ; + bool result; + + arg1 = (Dali::Property::Key *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + { + try { + result = (bool)(arg1)->operator !=(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; + Dali::Property::Key *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Key *)jarg1; + arg2 = (Dali::Property::Key *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0); + return 0; + } + { + try { + result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) { + Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; + + arg1 = (Dali::Property::Key *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() { + void * jresult ; + Dali::Property::Map *result = 0 ; + + { + try { + result = (Dali::Property::Map *)new Dali::Property::Map(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Property::Map *arg1 = 0 ; + Dali::Property::Map *result = 0 ; + + arg1 = (Dali::Property::Map *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) { + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + + arg1 = (Dali::Property::Map *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) { + unsigned long jresult ; + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + Dali::Property::Map::SizeType result; + + arg1 = (Dali::Property::Map *)jarg1; + { + try { + result = ((Dali::Property::Map const *)arg1)->Count(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) { + bool jresult ; + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + bool result; + + arg1 = (Dali::Property::Map *)jarg1; + { + try { + result = (bool)((Dali::Property::Map const *)arg1)->Empty(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) { + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + char *arg2 = (char *) 0 ; + Dali::Property::Value *arg3 = 0 ; + + arg1 = (Dali::Property::Map *)jarg1; + arg2 = (char *)jarg2; + arg3 = (Dali::Property::Value *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); + return ; + } + { + try { + (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) { + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + Dali::Property::Index arg2 ; + Dali::Property::Value *arg3 = 0 ; + + arg1 = (Dali::Property::Map *)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)->Insert(arg2,(Dali::Property::Value const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) { + void * jresult ; + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + char *arg2 = (char *) 0 ; + Dali::Property::Value *arg3 = 0 ; + Dali::Property::Map *result = 0 ; + + arg1 = (Dali::Property::Map *)jarg1; + arg2 = (char *)jarg2; + arg3 = (Dali::Property::Value *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) { + void * jresult ; + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + Dali::Property::Index arg2 ; + Dali::Property::Value *arg3 = 0 ; + Dali::Property::Map *result = 0 ; + + arg1 = (Dali::Property::Map *)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 0; + } + { + try { + result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + Dali::Property::Map::SizeType arg2 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Property::Map *)jarg1; + arg2 = (Dali::Property::Map::SizeType)jarg2; + { + try { + result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) { + char * jresult ; + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + Dali::Property::Map::SizeType arg2 ; + std::string *result = 0 ; + + arg1 = (Dali::Property::Map *)jarg1; + arg2 = (Dali::Property::Map::SizeType)jarg2; + { + try { + result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + Dali::Property::Map::SizeType arg2 ; + SwigValueWrapper< Dali::Property::Key > result; + + arg1 = (Dali::Property::Map *)jarg1; + arg2 = (Dali::Property::Map::SizeType)jarg2; + { + try { + result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Property::Key((const Dali::Property::Key &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + Dali::Property::Map::SizeType arg2 ; + StringValuePair *result = 0 ; + + arg1 = (Dali::Property::Map *)jarg1; + arg2 = (Dali::Property::Map::SizeType)jarg2; + { + try { + result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) { + void * jresult ; + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + char *arg2 = (char *) 0 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Property::Map *)jarg1; + arg2 = (char *)jarg2; + { + try { + result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) { + void * jresult ; + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + Dali::Property::Index arg2 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Property::Map *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + { + try { + result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) { + void * jresult ; + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + Dali::Property::Index arg2 ; + std::string *arg3 = 0 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Property::Map *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + if (!jarg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg3_str(jarg3); + arg3 = &arg3_str; + { + try { + result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) { + void * jresult ; + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + std::string *arg2 = 0 ; + Dali::Property::Type arg3 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Property::Map *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Property::Type)jarg3; + { + try { + result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) { + void * jresult ; + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + Dali::Property::Index arg2 ; + Dali::Property::Type arg3 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Property::Map *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + arg3 = (Dali::Property::Type)jarg3; + { + try { + result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) { + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + + arg1 = (Dali::Property::Map *)jarg1; + { + try { + (arg1)->Clear(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_0(void * map, int key) { + Dali::Property::Map *propertyMap = (Dali::Property::Map *)map; + Dali::Property::Index intKey = (Dali::Property::Index)key; + bool isRemoved = false; + { + try { + isRemoved = propertyMap->Remove(intKey); + } CALL_CATCH_EXCEPTION(0); + } + return isRemoved; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_1(void * map, char * key) { + Dali::Property::Map *propertyMap = (Dali::Property::Map *)map; + std::string strKey(key); + bool isRemoved = false; + { + try { + isRemoved = propertyMap->Remove(strKey); + } CALL_CATCH_EXCEPTION(0); + } + return isRemoved; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) { + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + Dali::Property::Map *arg2 = 0 ; + + arg1 = (Dali::Property::Map *)jarg1; + arg2 = (Dali::Property::Map *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); + return ; + } + { + try { + (arg1)->Merge((Dali::Property::Map const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) { + void * jresult ; + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + std::string *arg2 = 0 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Property::Map *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) { + void * jresult ; + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + Dali::Property::Index arg2 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Property::Map *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + { + try { + result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; + Dali::Property::Map *arg2 = 0 ; + Dali::Property::Map *result = 0 ; + + arg1 = (Dali::Property::Map *)jarg1; + arg2 = (Dali::Property::Map *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) { + + Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1; + + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return; + } + std::string arg2_str(jarg2); + std::string* arg2 = &arg2_str; + + Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3; + + { + try { + arg1->operator[]((std::string const &)*arg2) = *arg3; + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) { + + Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1; + Dali::Property::Index arg2 = (Dali::Property::Index)jarg2; + Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3; + + { + try { + arg1->operator[](arg2) = *arg3; + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() { + void * jresult ; + Dali::Property::Value *result = 0 ; + + { + try { + result = (Dali::Property::Value *)new Dali::Property::Value(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(bool jarg1) { + void * jresult ; + bool arg1 ; + Dali::Property::Value *result = 0 ; + + arg1 = jarg1 ? true : false; + { + try { + result = (Dali::Property::Value *)new Dali::Property::Value(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) { + void * jresult ; + int arg1 ; + Dali::Property::Value *result = 0 ; + + arg1 = (int)jarg1; + { + try { + result = (Dali::Property::Value *)new Dali::Property::Value(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) { + void * jresult ; + float arg1 ; + Dali::Property::Value *result = 0 ; + + arg1 = (float)jarg1; + { + try { + result = (Dali::Property::Value *)new Dali::Property::Value(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) { + void * jresult ; + Dali::Vector2 *arg1 = 0 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Vector2 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) { + void * jresult ; + Dali::Vector3 *arg1 = 0 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) { + void * jresult ; + Dali::Vector4 *arg1 = 0 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Vector4 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) { + void * jresult ; + Dali::Matrix3 *arg1 = 0 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Matrix3 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) { + void * jresult ; + Dali::Matrix *arg1 = 0 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Matrix *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) { + void * jresult ; + Dali::Rect< int > *arg1 = 0 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Rect< int > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) { + void * jresult ; + Dali::AngleAxis *arg1 = 0 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::AngleAxis *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) { + void * jresult ; + Dali::Quaternion *arg1 = 0 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Quaternion *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::Property::Value *result = 0 ; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + { + try { + result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) { + void * jresult ; + Dali::Property::Array *arg1 = 0 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Property::Array *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0); + return 0; + } + { + try { + result = (Dali::Property::Value *)new Dali::Property::Value(*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) { + void * jresult ; + Dali::Property::Map *arg1 = 0 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Property::Map *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0); + return 0; + } + { + try { + result = (Dali::Property::Value *)new Dali::Property::Value(*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) { + void * jresult ; + Extents *arg1 = 0 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Extents *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*) result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) { + void * jresult ; + Dali::Property::Type arg1 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Property::Type)jarg1; + { + try { + result = (Dali::Property::Value *)new Dali::Property::Value(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) { + void * jresult ; + Dali::Property::Value *arg1 = 0 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Property::Value *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + Dali::Property::Value *arg2 = 0 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Property::Value *)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::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_EqualTo(void * jarg1, void * jarg2) { + bool jresult; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + Dali::Property::Value *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Value *)jarg1; + arg2 = (Dali::Property::Value *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Property::Value const *)arg1)->operator ==((Dali::Property::Value const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_NotEqualTo(void * jarg1, void * jarg2) { + bool jresult; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + Dali::Property::Value *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Value *)jarg1; + arg2 = (Dali::Property::Value *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Property::Value const *)arg1)->operator !=((Dali::Property::Value const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) { + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + + arg1 = (Dali::Property::Value *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) { + int jresult ; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + Dali::Property::Type result; + + arg1 = (Dali::Property::Value *)jarg1; + { + try { + result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, bool * jarg2) { + bool jresult ; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + bool *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Value *)jarg1; + arg2 = (bool *)jarg2; + { + try { + result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) { + bool jresult ; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + float *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Value *)jarg1; + arg2 = (float *)jarg2; + { + try { + result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) { + bool jresult ; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + int *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Value *)jarg1; + arg2 = (int *)jarg2; + { + try { + result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + Dali::Rect< int > *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Value *)jarg1; + arg2 = (Dali::Rect< int > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + Dali::Vector2 *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Value *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + Dali::Vector3 *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Value *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + Dali::Vector4 *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Value *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + Dali::Matrix3 *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Value *)jarg1; + arg2 = (Dali::Matrix3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + Dali::Matrix *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Value *)jarg1; + arg2 = (Dali::Matrix *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + Dali::AngleAxis *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Value *)jarg1; + arg2 = (Dali::AngleAxis *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + Dali::Quaternion *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Value *)jarg1; + arg2 = (Dali::Quaternion *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) { + bool jresult ; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + std::string *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Value *)jarg1; + + //typemap in + std::string temp; + arg2 = &temp; + + { + try { + result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //Typemap argout in c++ file. + //This will convert c++ string to c# string + *jarg2 = SWIG_csharp_string_callback(arg2->c_str()); + + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + Dali::Property::Array *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Value *)jarg1; + arg2 = (Dali::Property::Array *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + Dali::Property::Map *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Value *)jarg1; + arg2 = (Dali::Property::Map *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + Extents *arg2 = 0 ; + bool result; + + arg1 = (Dali::Property::Value *)jarg1; + arg2 = (Extents *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) { + void * jresult ; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + Dali::Property::Array *result = 0 ; + + arg1 = (Dali::Property::Value *)jarg1; + { + try { + result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) { + void * jresult ; + Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; + Dali::Property::Map *result = 0 ; + + arg1 = (Dali::Property::Value *)jarg1; + { + try { + result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) { + char * jresult ; + Dali::Property::Type arg1 ; + char *result = 0 ; + + arg1 = (Dali::Property::Type)jarg1; + { + try { + result = (char *)Dali::PropertyTypes::GetName(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) { + bool jresult ; + Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ; + std::string *arg2 = 0 ; + Dali::Property::Map *arg3 = 0 ; + bool result; + + arg1 = (Dali::BaseObject *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Property::Map *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); + return 0; + } + { + try { + result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) { + char * jresult ; + Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ; + std::string *result = 0 ; + + arg1 = (Dali::BaseObject *)jarg1; + { + try { + result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) { + bool jresult ; + Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ; + Dali::TypeInfo *arg2 = 0 ; + bool result; + + arg1 = (Dali::BaseObject *)jarg1; + arg2 = (Dali::TypeInfo *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) { + bool jresult ; + Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ; + ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ; + std::string *arg3 = 0 ; + FunctorDelegate *arg4 = (FunctorDelegate *) 0 ; + bool result; + + arg1 = (Dali::BaseObject *)jarg1; + arg2 = (ConnectionTrackerInterface *)jarg2; + if (!jarg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg3_str(jarg3); + arg3 = &arg3_str; + arg4 = (FunctorDelegate *)jarg4; + { + try { + result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) { + void * jresult ; + Dali::BaseHandle *arg1 = 0 ; + Dali::BaseObject *result = 0 ; + + arg1 = (Dali::BaseHandle *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0); + return 0; + } + { + try { + result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) { + void * jresult ; + Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ; + Dali::BaseHandle *result = 0 ; + + arg1 = (Dali::BaseObject *)jarg1; + { + try { + result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() { + void * jresult ; + Dali::BaseHandle *result = 0 ; + + { + try { + result = (Dali::BaseHandle *)new Dali::BaseHandle(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) { + Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ; + + arg1 = (Dali::BaseHandle *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) { + void * jresult ; + Dali::BaseHandle *arg1 = 0 ; + Dali::BaseHandle *result = 0 ; + + arg1 = (Dali::BaseHandle *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0); + return 0; + } + { + try { + result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ; + Dali::BaseHandle *arg2 = 0 ; + Dali::BaseHandle *result = 0 ; + + 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 = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) { + bool jresult ; + Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ; + std::string *arg2 = 0 ; + Dali::Property::Map *arg3 = 0 ; + bool result; + + arg1 = (Dali::BaseHandle *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Property::Map *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); + return 0; + } + { + try { + result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) { + char * jresult ; + Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ; + std::string *result = 0 ; + + arg1 = (Dali::BaseHandle *)jarg1; + { + try { + result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) { + bool jresult ; + Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ; + Dali::TypeInfo *arg2 = 0 ; + bool result; + + arg1 = (Dali::BaseHandle *)jarg1; + arg2 = (Dali::TypeInfo *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) { + void * jresult ; + Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ; + Dali::BaseObject *result = 0 ; + + arg1 = (Dali::BaseHandle *)jarg1; + { + try { + result = (Dali::BaseObject *) &(arg1)->GetBaseObject(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) { + Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ; + + arg1 = (Dali::BaseHandle *)jarg1; + { + try { + (arg1)->Reset(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) { + bool 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 const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) { + bool 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 const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) { + void * jresult ; + Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ; + Dali::RefObject *result = 0 ; + + arg1 = (Dali::BaseHandle *)jarg1; + { + try { + result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) { + bool jresult ; + Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ; + bool result; + + arg1 = (Dali::BaseHandle *)jarg1; + { + try { + result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) { + bool 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_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) { + bool jresult ; + Dali::BaseHandle *arg1 = 0 ; + Dali::BaseHandle *arg2 = 0 ; + bool result; + + arg1 = (Dali::BaseHandle *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0); + return 0; + } + arg2 = (Dali::BaseHandle *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0); + return 0; + } + { + try { + result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) { + Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ; + + arg1 = (Dali::ConnectionTrackerInterface *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) { + Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ; + SlotObserver *arg2 = (SlotObserver *) 0 ; + CallbackBase *arg3 = (CallbackBase *) 0 ; + + arg1 = (Dali::ConnectionTrackerInterface *)jarg1; + arg2 = (SlotObserver *)jarg2; + arg3 = (CallbackBase *)jarg3; + { + try { + (arg1)->SignalConnected(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) { + Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ; + + arg1 = (Dali::SignalObserver *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) { + Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ; + Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; + Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; + + arg1 = (Dali::SignalObserver *)jarg1; + arg2 = (Dali::SlotObserver *)jarg2; + arg3 = (Dali::CallbackBase *)jarg3; + { + try { + (arg1)->SignalDisconnected(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) { + Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ; + + arg1 = (Dali::SlotObserver *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) { + Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ; + Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ; + + arg1 = (Dali::SlotObserver *)jarg1; + arg2 = (Dali::CallbackBase *)jarg2; + { + try { + (arg1)->SlotDisconnected(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) { + Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ; + + arg1 = (Dali::ConnectionTracker *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) { + Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ; + + arg1 = (Dali::ConnectionTracker *)jarg1; + { + try { + (arg1)->DisconnectAll(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) { + Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ; + Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; + Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; + + arg1 = (Dali::ConnectionTracker *)jarg1; + arg2 = (Dali::SlotObserver *)jarg2; + arg3 = (Dali::CallbackBase *)jarg3; + { + try { + (arg1)->SignalConnected(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) { + Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ; + Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; + Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; + + arg1 = (Dali::ConnectionTracker *)jarg1; + arg2 = (Dali::SlotObserver *)jarg2; + arg3 = (Dali::CallbackBase *)jarg3; + { + try { + (arg1)->SignalDisconnected(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ; + std::size_t result; + + arg1 = (Dali::ConnectionTracker *)jarg1; + { + try { + result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() { + void * jresult ; + Dali::ObjectRegistry *result = 0 ; + + { + try { + result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) { + Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ; + + arg1 = (Dali::ObjectRegistry *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) { + void * jresult ; + Dali::ObjectRegistry *arg1 = 0 ; + Dali::ObjectRegistry *result = 0 ; + + arg1 = (Dali::ObjectRegistry *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0); + return 0; + } + { + try { + result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ; + Dali::ObjectRegistry *arg2 = 0 ; + Dali::ObjectRegistry *result = 0 ; + + arg1 = (Dali::ObjectRegistry *)jarg1; + arg2 = (Dali::ObjectRegistry *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0); + return 0; + } + { + try { + result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) { + void * jresult ; + Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ; + Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ; + + arg1 = (Dali::ObjectRegistry *)jarg1; + { + try { + result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) { + void * jresult ; + Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ; + Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ; + + arg1 = (Dali::ObjectRegistry *)jarg1; + { + try { + result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() { + void * jresult ; + Dali::PropertyCondition *result = 0 ; + + { + try { + result = (Dali::PropertyCondition *)new Dali::PropertyCondition(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) { + Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ; + + arg1 = (Dali::PropertyCondition *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) { + void * jresult ; + Dali::PropertyCondition *arg1 = 0 ; + Dali::PropertyCondition *result = 0 ; + + arg1 = (Dali::PropertyCondition *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0); + return 0; + } + { + try { + result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ; + Dali::PropertyCondition *arg2 = 0 ; + Dali::PropertyCondition *result = 0 ; + + arg1 = (Dali::PropertyCondition *)jarg1; + arg2 = (Dali::PropertyCondition *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0); + return 0; + } + { + try { + result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) { + unsigned long jresult ; + Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ; + std::size_t result; + + arg1 = (Dali::PropertyCondition *)jarg1; + { + try { + result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) { + float jresult ; + Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ; + std::size_t arg2 ; + float result; + + arg1 = (Dali::PropertyCondition *)jarg1; + arg2 = (std::size_t)jarg2; + { + try { + result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) { + void * jresult ; + float arg1 ; + Dali::PropertyCondition result; + + arg1 = (float)jarg1; + { + try { + result = Dali::LessThanCondition(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) { + void * jresult ; + float arg1 ; + Dali::PropertyCondition result; + + arg1 = (float)jarg1; + { + try { + result = Dali::GreaterThanCondition(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) { + void * jresult ; + float arg1 ; + float arg2 ; + Dali::PropertyCondition result; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + { + try { + result = Dali::InsideCondition(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) { + void * jresult ; + float arg1 ; + float arg2 ; + Dali::PropertyCondition result; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + { + try { + result = Dali::OutsideCondition(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) { + void * jresult ; + float arg1 ; + float arg2 ; + Dali::PropertyCondition result; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + { + try { + result = Dali::StepCondition(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) { + void * jresult ; + float arg1 ; + Dali::PropertyCondition result; + + arg1 = (float)jarg1; + { + try { + result = Dali::StepCondition(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) { + void * jresult ; + Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ; + Dali::PropertyCondition result; + + arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0); + return 0; + } + { + try { + result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() { + void * jresult ; + Dali::PropertyNotification *result = 0 ; + + { + try { + result = (Dali::PropertyNotification *)new Dali::PropertyNotification(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::PropertyNotification 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::PropertyNotification::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) { + Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ; + + arg1 = (Dali::PropertyNotification *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) { + void * jresult ; + Dali::PropertyNotification *arg1 = 0 ; + Dali::PropertyNotification *result = 0 ; + + arg1 = (Dali::PropertyNotification *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0); + return 0; + } + { + try { + result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ; + Dali::PropertyNotification *arg2 = 0 ; + Dali::PropertyNotification *result = 0 ; + + arg1 = (Dali::PropertyNotification *)jarg1; + arg2 = (Dali::PropertyNotification *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0); + return 0; + } + { + try { + result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) { + void * jresult ; + Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ; + Dali::PropertyCondition result; + + arg1 = (Dali::PropertyNotification *)jarg1; + { + try { + result = (arg1)->GetCondition(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) { + void * jresult ; + Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ; + Dali::Handle result; + + arg1 = (Dali::PropertyNotification *)jarg1; + { + try { + result = ((Dali::PropertyNotification const *)arg1)->GetTarget(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Handle((const Dali::Handle &)result); + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) { + int jresult ; + Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ; + Dali::Property::Index result; + + arg1 = (Dali::PropertyNotification *)jarg1; + { + try { + result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) { + Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ; + Dali::PropertyNotification::NotifyMode arg2 ; + + arg1 = (Dali::PropertyNotification *)jarg1; + arg2 = (Dali::PropertyNotification::NotifyMode)jarg2; + { + try { + (arg1)->SetNotifyMode(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) { + int jresult ; + Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ; + Dali::PropertyNotification::NotifyMode result; + + arg1 = (Dali::PropertyNotification *)jarg1; + { + try { + result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) { + bool jresult ; + Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ; + bool result; + + arg1 = (Dali::PropertyNotification *)jarg1; + { + try { + result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) { + void * jresult ; + Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ; + Dali::PropertyNotifySignalType *result = 0 ; + + arg1 = (Dali::PropertyNotification *)jarg1; + { + try { + result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() { + void * jresult ; + Dali::Handle *result = 0 ; + + { + try { + result = (Dali::Handle *)new Dali::Handle(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() { + void * jresult ; + Dali::Handle result; + + { + try { + result = Dali::Handle::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Handle((const Dali::Handle &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) { + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + + arg1 = (Dali::Handle *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Handle *arg1 = 0 ; + Dali::Handle *result = 0 ; + + arg1 = (Dali::Handle *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + Dali::Handle *arg2 = 0 ; + Dali::Handle *result = 0 ; + + arg1 = (Dali::Handle *)jarg1; + arg2 = (Dali::Handle *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Handle 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::Handle::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Handle((const Dali::Handle &)result); + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) { + bool jresult ; + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + Dali::Handle::Capability arg2 ; + bool result; + + arg1 = (Dali::Handle *)jarg1; + arg2 = (Dali::Handle::Capability)jarg2; + { + try { + result = (bool)((Dali::Handle const *)arg1)->Supports(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) { + unsigned int jresult ; + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + unsigned int result; + + arg1 = (Dali::Handle *)jarg1; + { + try { + result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) { + char * jresult ; + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + Dali::Property::Index arg2 ; + std::string result; + + arg1 = (Dali::Handle *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + { + try { + result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback((&result)->c_str()); + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) { + int jresult ; + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + std::string *arg2 = 0 ; + Dali::Property::Index result; + + arg1 = (Dali::Handle *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) { + bool jresult ; + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + Dali::Property::Index arg2 ; + bool result; + + arg1 = (Dali::Handle *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + { + try { + result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) { + bool jresult ; + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + Dali::Property::Index arg2 ; + bool result; + + arg1 = (Dali::Handle *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + { + try { + result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) { + bool jresult ; + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + Dali::Property::Index arg2 ; + bool result; + + arg1 = (Dali::Handle *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + { + try { + result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) { + int jresult ; + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + Dali::Property::Index arg2 ; + Dali::Property::Type result; + + arg1 = (Dali::Handle *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + { + try { + result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) { + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + Dali::Property::Index arg2 ; + Dali::Property::Value *arg3 = 0 ; + + arg1 = (Dali::Handle *)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); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) { + int jresult ; + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + std::string *arg2 = 0 ; + Dali::Property::Value *arg3 = 0 ; + Dali::Property::Index result; + + arg1 = (Dali::Handle *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Property::Value *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) { + int jresult ; + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + std::string *arg2 = 0 ; + Dali::Property::Value *arg3 = 0 ; + Dali::Property::AccessMode arg4 ; + Dali::Property::Index result; + + arg1 = (Dali::Handle *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Property::Value *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); + return 0; + } + arg4 = (Dali::Property::AccessMode)jarg4; + { + try { + result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) { + void * jresult ; + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + Dali::Property::Index arg2 ; + Dali::Property::Value result; + + arg1 = (Dali::Handle *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + { + try { + result = ((Dali::Handle const *)arg1)->GetProperty(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Property::Value((const Dali::Property::Value &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetCurrentProperty(void * jarg1, int jarg2) { + void * jresult ; + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + Dali::Property::Index arg2 ; + Dali::Property::Value result; + + arg1 = (Dali::Handle *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + { + try { + result = ((Dali::Handle const *)arg1)->GetCurrentProperty(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Property::Value((const Dali::Property::Value &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) { + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + Dali::Property::IndexContainer *arg2 = 0 ; + + arg1 = (Dali::Handle *)jarg1; + arg2 = (Dali::Property::IndexContainer *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0); + return ; + } + { + try { + ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) { + void * jresult ; + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + Dali::Property::Index arg2 ; + Dali::PropertyCondition *arg3 = 0 ; + Dali::PropertyNotification result; + + arg1 = (Dali::Handle *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + arg3 = (Dali::PropertyCondition *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0); + return 0; + } + { + try { + result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) { + void * jresult ; + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + Dali::Property::Index arg2 ; + int arg3 ; + Dali::PropertyCondition *arg4 = 0 ; + Dali::PropertyNotification result; + + arg1 = (Dali::Handle *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + arg3 = (int)jarg3; + arg4 = (Dali::PropertyCondition *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0); + return 0; + } + { + try { + result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) { + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + Dali::PropertyNotification arg2 ; + Dali::PropertyNotification *argp2 ; + + arg1 = (Dali::Handle *)jarg1; + argp2 = (Dali::PropertyNotification *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->RemovePropertyNotification(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) { + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + + arg1 = (Dali::Handle *)jarg1; + { + try { + (arg1)->RemovePropertyNotifications(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) { + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + + arg1 = (Dali::Handle *)jarg1; + { + try { + (arg1)->RemoveConstraints(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) { + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Handle *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + (arg1)->RemoveConstraints(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() { + void * jresult ; + Dali::Handle result; + + { + try { + result = Dali::WeightObject::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Handle((const Dali::Handle &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() { + void * jresult ; + Dali::TypeInfo *result = 0 ; + + { + try { + result = (Dali::TypeInfo *)new Dali::TypeInfo(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) { + Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; + + arg1 = (Dali::TypeInfo *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) { + void * jresult ; + Dali::TypeInfo *arg1 = 0 ; + Dali::TypeInfo *result = 0 ; + + arg1 = (Dali::TypeInfo *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0); + return 0; + } + { + try { + result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; + Dali::TypeInfo *arg2 = 0 ; + Dali::TypeInfo *result = 0 ; + + arg1 = (Dali::TypeInfo *)jarg1; + arg2 = (Dali::TypeInfo *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0); + return 0; + } + { + try { + result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) { + char * jresult ; + Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; + std::string *result = 0 ; + + arg1 = (Dali::TypeInfo *)jarg1; + { + try { + result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) { + char * jresult ; + Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; + std::string *result = 0 ; + + arg1 = (Dali::TypeInfo *)jarg1; + { + try { + result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) { + void * jresult ; + Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; + Dali::BaseHandle result; + + arg1 = (Dali::TypeInfo *)jarg1; + { + try { + result = ((Dali::TypeInfo const *)arg1)->CreateInstance(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result); + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) { + unsigned long jresult ; + Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; + size_t result; + + arg1 = (Dali::TypeInfo *)jarg1; + { + try { + result = ((Dali::TypeInfo const *)arg1)->GetActionCount(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) { + char * jresult ; + Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; + size_t arg2 ; + std::string result; + + arg1 = (Dali::TypeInfo *)jarg1; + arg2 = (size_t)jarg2; + { + try { + result = (arg1)->GetActionName(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback((&result)->c_str()); + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) { + unsigned long jresult ; + Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; + size_t result; + + arg1 = (Dali::TypeInfo *)jarg1; + { + try { + result = ((Dali::TypeInfo const *)arg1)->GetSignalCount(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) { + char * jresult ; + Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; + size_t arg2 ; + std::string result; + + arg1 = (Dali::TypeInfo *)jarg1; + arg2 = (size_t)jarg2; + { + try { + result = (arg1)->GetSignalName(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback((&result)->c_str()); + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) { + unsigned long jresult ; + Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; + size_t result; + + arg1 = (Dali::TypeInfo *)jarg1; + { + try { + result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) { + Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; + Dali::Property::IndexContainer *arg2 = 0 ; + + arg1 = (Dali::TypeInfo *)jarg1; + arg2 = (Dali::Property::IndexContainer *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0); + return ; + } + { + try { + ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) { + char * jresult ; + Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; + Dali::Property::Index arg2 ; + std::string_view result; + + arg1 = (Dali::TypeInfo *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + { + try { + result = ((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback(result.data()); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() { + void * jresult ; + Dali::TypeRegistry result; + + { + try { + result = Dali::TypeRegistry::Get(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() { + void * jresult ; + Dali::TypeRegistry *result = 0 ; + + { + try { + result = (Dali::TypeRegistry *)new Dali::TypeRegistry(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) { + Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ; + + arg1 = (Dali::TypeRegistry *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) { + void * jresult ; + Dali::TypeRegistry *arg1 = 0 ; + Dali::TypeRegistry *result = 0 ; + + arg1 = (Dali::TypeRegistry *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0); + return 0; + } + { + try { + result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ; + Dali::TypeRegistry *arg2 = 0 ; + Dali::TypeRegistry *result = 0 ; + + arg1 = (Dali::TypeRegistry *)jarg1; + arg2 = (Dali::TypeRegistry *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0); + return 0; + } + { + try { + result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) { + void * jresult ; + Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ; + std::string *arg2 = 0 ; + Dali::TypeInfo result; + + arg1 = (Dali::TypeRegistry *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + result = (arg1)->GetTypeInfo((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) { + void * jresult ; + Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ; + std::type_info *arg2 = 0 ; + Dali::TypeInfo result; + + arg1 = (Dali::TypeRegistry *)jarg1; + arg2 = (std::type_info *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0); + return 0; + } + { + try { + result = (arg1)->GetTypeInfo((std::type_info const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result); + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) { + unsigned long jresult ; + Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ; + size_t result; + + arg1 = (Dali::TypeRegistry *)jarg1; + { + try { + result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) { + char * jresult ; + Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ; + size_t arg2 ; + std::string result; + + arg1 = (Dali::TypeRegistry *)jarg1; + arg2 = (size_t)jarg2; + { + try { + result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback((&result)->c_str()); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { + void * jresult ; + std::type_info *arg1 = 0 ; + std::type_info *arg2 = 0 ; + Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ; + Dali::TypeRegistration *result = 0 ; + + arg1 = (std::type_info *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0); + return 0; + } + arg2 = (std::type_info *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0); + return 0; + } + arg3 = (Dali::TypeInfo::CreateFunction)jarg3; + { + try { + result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, bool jarg4) { + void * jresult ; + std::type_info *arg1 = 0 ; + std::type_info *arg2 = 0 ; + Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ; + bool arg4 ; + Dali::TypeRegistration *result = 0 ; + + arg1 = (std::type_info *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0); + return 0; + } + arg2 = (std::type_info *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0); + return 0; + } + arg3 = (Dali::TypeInfo::CreateFunction)jarg3; + arg4 = jarg4 ? true : false; + { + try { + result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) { + void * jresult ; + std::string *arg1 = 0 ; + std::type_info *arg2 = 0 ; + Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ; + Dali::TypeRegistration *result = 0 ; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + arg2 = (std::type_info *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0); + return 0; + } + arg3 = (Dali::TypeInfo::CreateFunction)jarg3; + { + try { + result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) { + char * jresult ; + Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ; + std::string result; + + arg1 = (Dali::TypeRegistration *)jarg1; + { + try { + result = ((Dali::TypeRegistration const *)arg1)->RegisteredName(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback((&result)->c_str()); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) { + std::string *arg1 = 0 ; + Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2; + { + try { + Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) { + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + int arg3 ; + Dali::Property::Type arg4 ; + Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ; + Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (int)jarg3; + arg4 = (Dali::Property::Type)jarg4; + arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5; + arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6; + { + try { + Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6); + } CALL_CATCH_EXCEPTION(); + } + + + //argout typemap for const std::string& + + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) { + Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ; + + arg1 = (Dali::TypeRegistration *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) { + void * jresult ; + Dali::TypeRegistration *arg1 = 0 ; + std::string *arg2 = 0 ; + Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ; + Dali::SignalConnectorType *result = 0 ; + + arg1 = (Dali::TypeRegistration *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0); + return 0; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3; + { + try { + result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) { + Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ; + + arg1 = (Dali::SignalConnectorType *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) { + void * jresult ; + Dali::TypeRegistration *arg1 = 0 ; + std::string *arg2 = 0 ; + Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ; + Dali::TypeAction *result = 0 ; + + arg1 = (Dali::TypeRegistration *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0); + return 0; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::TypeInfo::ActionFunction)jarg3; + { + try { + result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) { + Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ; + + arg1 = (Dali::TypeAction *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) { + void * jresult ; + Dali::TypeRegistration *arg1 = 0 ; + std::string *arg2 = 0 ; + Dali::Property::Index arg3 ; + Dali::Property::Type arg4 ; + Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ; + Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ; + Dali::PropertyRegistration *result = 0 ; + + arg1 = (Dali::TypeRegistration *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0); + return 0; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Property::Index)jarg3; + arg4 = (Dali::Property::Type)jarg4; + arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5; + arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6; + { + try { + result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) { + Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ; + + arg1 = (Dali::PropertyRegistration *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) { + void * jresult ; + Dali::TypeRegistration *arg1 = 0 ; + std::string *arg2 = 0 ; + Dali::Property::Index arg3 ; + Dali::Property::Type arg4 ; + Dali::AnimatablePropertyRegistration *result = 0 ; + + arg1 = (Dali::TypeRegistration *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0); + return 0; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Property::Index)jarg3; + arg4 = (Dali::Property::Type)jarg4; + { + try { + result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) { + void * jresult ; + Dali::TypeRegistration *arg1 = 0 ; + std::string *arg2 = 0 ; + Dali::Property::Index arg3 ; + Dali::Property::Value *arg4 = 0 ; + Dali::AnimatablePropertyRegistration *result = 0 ; + + arg1 = (Dali::TypeRegistration *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0); + return 0; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Property::Index)jarg3; + arg4 = (Dali::Property::Value *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); + return 0; + } + { + try { + result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) { + Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ; + + arg1 = (Dali::AnimatablePropertyRegistration *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) { + void * jresult ; + Dali::TypeRegistration *arg1 = 0 ; + std::string *arg2 = 0 ; + Dali::Property::Index arg3 ; + Dali::Property::Index arg4 ; + unsigned int arg5 ; + Dali::AnimatablePropertyComponentRegistration *result = 0 ; + + arg1 = (Dali::TypeRegistration *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0); + return 0; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Property::Index)jarg3; + arg4 = (Dali::Property::Index)jarg4; + arg5 = (unsigned int)jarg5; + { + try { + result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) { + Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ; + + arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) { + void * jresult ; + Dali::TypeRegistration *arg1 = 0 ; + std::string *arg2 = 0 ; + Dali::Property::Index arg3 ; + Dali::Property::Type arg4 ; + Dali::ChildPropertyRegistration *result = 0 ; + + arg1 = (Dali::TypeRegistration *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0); + return 0; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Property::Index)jarg3; + arg4 = (Dali::Property::Type)jarg4; + { + try { + result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) { + Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ; + + arg1 = (Dali::ChildPropertyRegistration *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) { + bool jresult ; + std::string *arg1 = 0 ; + std::type_info *arg2 = 0 ; + Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ; + bool result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + arg2 = (std::type_info *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0); + return 0; + } + arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3; + { + try { + result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) { + bool jresult ; + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + Dali::Property::Index arg3 ; + Dali::Property::Type arg4 ; + Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ; + Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ; + bool result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Property::Index)jarg3; + arg4 = (Dali::Property::Type)jarg4; + arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5; + arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6; + { + try { + result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() { + int jresult ; + Dali::ResizePolicy::Type result; + + result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) { + unsigned long jresult ; + Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ; + Dali::VectorBase::SizeType result; + + arg1 = (Dali::VectorBase *)jarg1; + { + try { + result = ((Dali::VectorBase const *)arg1)->Count(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) { + unsigned long jresult ; + Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ; + Dali::VectorBase::SizeType result; + + arg1 = (Dali::VectorBase *)jarg1; + { + try { + result = ((Dali::VectorBase const *)arg1)->Size(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) { + bool jresult ; + Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ; + bool result; + + arg1 = (Dali::VectorBase *)jarg1; + { + try { + result = (bool)((Dali::VectorBase const *)arg1)->Empty(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) { + unsigned long jresult ; + Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ; + Dali::VectorBase::SizeType result; + + arg1 = (Dali::VectorBase *)jarg1; + { + try { + result = ((Dali::VectorBase const *)arg1)->Capacity(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) { + Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ; + + arg1 = (Dali::VectorBase *)jarg1; + { + try { + (arg1)->Release(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() { + int jresult ; + Dali::Pixel::Format result; + + result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() { + int jresult ; + Dali::Pixel::Format result; + + result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) { + bool jresult ; + Dali::Pixel::Format arg1 ; + bool result; + + arg1 = (Dali::Pixel::Format)jarg1; + { + try { + result = (bool)Dali::Pixel::HasAlpha(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) { + unsigned int jresult ; + Dali::Pixel::Format arg1 ; + unsigned int result; + + arg1 = (Dali::Pixel::Format)jarg1; + { + try { + result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) { + Dali::Pixel::Format arg1 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + + arg1 = (Dali::Pixel::Format)jarg1; + arg2 = (int *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0); + return ; + } + arg3 = (int *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0); + return ; + } + { + try { + Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* nuiBuffer, unsigned int nuiBufferSize, unsigned int nuiWidth, unsigned int nuiHeight, int nuiPixelFormat) { + void * jresult ; + Dali::PixelData result; + + { + unsigned char* copiedBuffer; + try + { + copiedBuffer = new unsigned char[nuiBufferSize]; + } CALL_CATCH_EXCEPTION(0); + + try + { + // Note : copiedBuffer created by 'new' method. So ReleaseFunction always be DELETE_ARRAY. + memcpy(copiedBuffer, nuiBuffer, nuiBufferSize); + result = Dali::PixelData::New(copiedBuffer, nuiBufferSize, nuiWidth, nuiHeight, (Dali::Pixel::Format)nuiPixelFormat, Dali::PixelData::ReleaseFunction::DELETE_ARRAY); + } CALL_CATCH_EXCEPTION_WITH_FUNCTION(0, [](unsigned char* buffer){delete[] buffer;}, copiedBuffer); + } + + jresult = new Dali::PixelData((const Dali::PixelData &)result); + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() { + void * jresult ; + Dali::PixelData *result = 0 ; + + { + try { + result = (Dali::PixelData *)new Dali::PixelData(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * nuiHandle) { + Dali::PixelData *pixelData = (Dali::PixelData *) 0 ; + + pixelData = (Dali::PixelData *)nuiHandle; + { + try { + delete pixelData; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * nuiHandle) { + void * jresult ; + Dali::PixelData *pixelData = 0 ; + Dali::PixelData *result = 0 ; + + pixelData = (Dali::PixelData *)nuiHandle; + if (!pixelData) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0); + return 0; + } + { + try { + result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*pixelData); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * nuiHandle, void * nuiHandleSource) { + void * jresult ; + Dali::PixelData *pixelData = (Dali::PixelData *) 0 ; + Dali::PixelData *pixelDataSource = 0 ; + Dali::PixelData *result = 0 ; + + pixelData = (Dali::PixelData *)nuiHandle; + pixelDataSource = (Dali::PixelData *)nuiHandleSource; + if (!pixelDataSource) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0); + return 0; + } + { + try { + result = (Dali::PixelData *) &(pixelData)->operator =((Dali::PixelData const &)*pixelDataSource); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * nuiHandle) { + unsigned int jresult ; + Dali::PixelData *pixelData = (Dali::PixelData *) 0 ; + unsigned int result; + + pixelData = (Dali::PixelData *)nuiHandle; + { + try { + result = (unsigned int)((Dali::PixelData const *)pixelData)->GetWidth(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * nuiHandle) { + unsigned int jresult ; + Dali::PixelData *pixelData = (Dali::PixelData *) 0 ; + unsigned int result; + + pixelData = (Dali::PixelData *)nuiHandle; + { + try { + result = (unsigned int)((Dali::PixelData const *)pixelData)->GetHeight(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * nuiHandle) { + int jresult ; + Dali::PixelData *pixelData = (Dali::PixelData *) 0 ; + Dali::Pixel::Format result; + + pixelData = (Dali::PixelData *)nuiHandle; + { + try { + result = (Dali::Pixel::Format)((Dali::PixelData const *)pixelData)->GetPixelFormat(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PixelData_GenerateUrl(void* nuiHandle) +{ + Dali::PixelData *pixelData = (Dali::PixelData*)nuiHandle; + Dali::Toolkit::ImageUrl result; + void *jresult; + + if (!pixelData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); + return 0; + } + { + try + { + result = Dali::Toolkit::Image::GenerateUrl(*pixelData); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl&)result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() { + unsigned int jresult ; + unsigned int result; + + result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X; + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() { + unsigned int jresult ; + unsigned int result; + + result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X; + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() { + unsigned int jresult ; + unsigned int result; + + result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y; + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() { + unsigned int jresult ; + unsigned int result; + + result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y; + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() { + unsigned int jresult ; + unsigned int result; + + result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z; + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() { + unsigned int jresult ; + unsigned int result; + + result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z; + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) { + void * jresult ; + Dali::TextureType::Type arg1 ; + Dali::Pixel::Format arg2 ; + unsigned int arg3 ; + unsigned int arg4 ; + Dali::Texture result; + + arg1 = (Dali::TextureType::Type)jarg1; + arg2 = (Dali::Pixel::Format)jarg2; + arg3 = (unsigned int)jarg3; + arg4 = (unsigned int)jarg4; + { + try { + result = Dali::Texture::New(arg1,arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Texture((const Dali::Texture &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) { + void * jresult ; + NativeImageInterface *arg1 = 0 ; + Dali::Texture result; + + arg1 = (NativeImageInterface *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0); + return 0; + } + { + try { + result = Dali::Texture::New(*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Texture((const Dali::Texture &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() { + void * jresult ; + Dali::Texture *result = 0 ; + + { + try { + result = (Dali::Texture *)new Dali::Texture(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) { + Dali::Texture *arg1 = (Dali::Texture *) 0 ; + + arg1 = (Dali::Texture *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Texture *arg1 = 0 ; + Dali::Texture *result = 0 ; + + arg1 = (Dali::Texture *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Texture 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::Texture::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Texture((const Dali::Texture &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Texture *arg1 = (Dali::Texture *) 0 ; + Dali::Texture *arg2 = 0 ; + Dali::Texture *result = 0 ; + + arg1 = (Dali::Texture *)jarg1; + arg2 = (Dali::Texture *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Texture *arg1 = (Dali::Texture *) 0 ; + Dali::PixelData arg2 ; + Dali::PixelData *argp2 ; + bool result; + + arg1 = (Dali::Texture *)jarg1; + argp2 = (Dali::PixelData *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)(arg1)->Upload(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, unsigned int jarg6, unsigned int jarg7, unsigned int jarg8) { + bool jresult ; + Dali::Texture *arg1 = (Dali::Texture *) 0 ; + Dali::PixelData arg2 ; + unsigned int arg3 ; + unsigned int arg4 ; + unsigned int arg5 ; + unsigned int arg6 ; + unsigned int arg7 ; + unsigned int arg8 ; + Dali::PixelData *argp2 ; + bool result; + + arg1 = (Dali::Texture *)jarg1; + argp2 = (Dali::PixelData *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0); + return 0; + } + arg2 = *argp2; + arg3 = (unsigned int)jarg3; + arg4 = (unsigned int)jarg4; + arg5 = (unsigned int)jarg5; + arg6 = (unsigned int)jarg6; + arg7 = (unsigned int)jarg7; + arg8 = (unsigned int)jarg8; + { + try { + result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) { + Dali::Texture *arg1 = (Dali::Texture *) 0 ; + + arg1 = (Dali::Texture *)jarg1; + { + try { + (arg1)->GenerateMipmaps(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) { + unsigned int jresult ; + Dali::Texture *arg1 = (Dali::Texture *) 0 ; + unsigned int result; + + arg1 = (Dali::Texture *)jarg1; + { + try { + result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) { + unsigned int jresult ; + Dali::Texture *arg1 = (Dali::Texture *) 0 ; + unsigned int result; + + arg1 = (Dali::Texture *)jarg1; + { + try { + result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() { + void * jresult ; + Dali::Sampler result; + + { + try { + result = Dali::Sampler::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Sampler((const Dali::Sampler &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() { + void * jresult ; + Dali::Sampler *result = 0 ; + + { + try { + result = (Dali::Sampler *)new Dali::Sampler(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) { + Dali::Sampler *arg1 = (Dali::Sampler *) 0 ; + + arg1 = (Dali::Sampler *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Sampler *arg1 = 0 ; + Dali::Sampler *result = 0 ; + + arg1 = (Dali::Sampler *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Sampler 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::Sampler::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Sampler((const Dali::Sampler &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Sampler *arg1 = (Dali::Sampler *) 0 ; + Dali::Sampler *arg2 = 0 ; + Dali::Sampler *result = 0 ; + + arg1 = (Dali::Sampler *)jarg1; + arg2 = (Dali::Sampler *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) { + Dali::Sampler *arg1 = (Dali::Sampler *) 0 ; + Dali::FilterMode::Type arg2 ; + Dali::FilterMode::Type arg3 ; + + arg1 = (Dali::Sampler *)jarg1; + arg2 = (Dali::FilterMode::Type)jarg2; + arg3 = (Dali::FilterMode::Type)jarg3; + { + try { + (arg1)->SetFilterMode(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) { + Dali::Sampler *arg1 = (Dali::Sampler *) 0 ; + Dali::WrapMode::Type arg2 ; + Dali::WrapMode::Type arg3 ; + + arg1 = (Dali::Sampler *)jarg1; + arg2 = (Dali::WrapMode::Type)jarg2; + arg3 = (Dali::WrapMode::Type)jarg3; + { + try { + (arg1)->SetWrapMode(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) { + Dali::Sampler *arg1 = (Dali::Sampler *) 0 ; + Dali::WrapMode::Type arg2 ; + Dali::WrapMode::Type arg3 ; + Dali::WrapMode::Type arg4 ; + + arg1 = (Dali::Sampler *)jarg1; + arg2 = (Dali::WrapMode::Type)jarg2; + arg3 = (Dali::WrapMode::Type)jarg3; + arg4 = (Dali::WrapMode::Type)jarg4; + { + try { + (arg1)->SetWrapMode(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() { + void * jresult ; + Dali::TextureSet result; + + { + try { + result = Dali::TextureSet::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::TextureSet((const Dali::TextureSet &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() { + void * jresult ; + Dali::TextureSet *result = 0 ; + + { + try { + result = (Dali::TextureSet *)new Dali::TextureSet(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) { + Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ; + + arg1 = (Dali::TextureSet *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) { + void * jresult ; + Dali::TextureSet *arg1 = 0 ; + Dali::TextureSet *result = 0 ; + + arg1 = (Dali::TextureSet *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0); + return 0; + } + { + try { + result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::TextureSet 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::TextureSet::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::TextureSet((const Dali::TextureSet &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ; + Dali::TextureSet *arg2 = 0 ; + Dali::TextureSet *result = 0 ; + + arg1 = (Dali::TextureSet *)jarg1; + arg2 = (Dali::TextureSet *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0); + return 0; + } + { + try { + result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) { + Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ; + size_t arg2 ; + Dali::Texture arg3 ; + Dali::Texture *argp3 ; + + arg1 = (Dali::TextureSet *)jarg1; + arg2 = (size_t)jarg2; + argp3 = (Dali::Texture *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0); + return ; + } + arg3 = *argp3; + { + try { + (arg1)->SetTexture(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ; + size_t arg2 ; + Dali::Texture result; + + arg1 = (Dali::TextureSet *)jarg1; + arg2 = (size_t)jarg2; + { + try { + result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Texture((const Dali::Texture &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) { + Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ; + size_t arg2 ; + Dali::Sampler arg3 ; + Dali::Sampler *argp3 ; + + arg1 = (Dali::TextureSet *)jarg1; + arg2 = (size_t)jarg2; + argp3 = (Dali::Sampler *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0); + return ; + } + arg3 = *argp3; + { + try { + (arg1)->SetSampler(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ; + size_t arg2 ; + Dali::Sampler result; + + arg1 = (Dali::TextureSet *)jarg1; + arg2 = (size_t)jarg2; + { + try { + result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Sampler((const Dali::Sampler &)result); + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) { + unsigned long jresult ; + Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ; + size_t result; + + arg1 = (Dali::TextureSet *)jarg1; + { + try { + result = ((Dali::TextureSet const *)arg1)->GetTextureCount(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_New(void * jarg1) { + void * jresult ; + Dali::Property::Map *arg1 = 0 ; + Dali::VertexBuffer result; + + arg1 = (Dali::Property::Map *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0); + return 0; + } + { + try { + result = Dali::VertexBuffer::New(*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_0() { + void * jresult ; + Dali::VertexBuffer *result = 0 ; + + { + try { + result = (Dali::VertexBuffer *)new Dali::VertexBuffer(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VertexBuffer(void * jarg1) { + Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ; + + arg1 = (Dali::VertexBuffer *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_1(void * jarg1) { + void * jresult ; + Dali::VertexBuffer *arg1 = 0 ; + Dali::VertexBuffer *result = 0 ; + + arg1 = (Dali::VertexBuffer *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0); + return 0; + } + { + try { + result = (Dali::VertexBuffer *)new Dali::VertexBuffer((Dali::VertexBuffer const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::VertexBuffer 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::VertexBuffer::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ; + Dali::VertexBuffer *arg2 = 0 ; + Dali::VertexBuffer *result = 0 ; + + arg1 = (Dali::VertexBuffer *)jarg1; + arg2 = (Dali::VertexBuffer *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0); + return 0; + } + { + try { + result = (Dali::VertexBuffer *) &(arg1)->operator =((Dali::VertexBuffer const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VertexBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) { + Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ; + void *arg2 = (void *) 0 ; + std::size_t arg3 ; + + arg1 = (Dali::VertexBuffer *)jarg1; + arg2 = jarg2; + arg3 = (std::size_t)jarg3; + { + try { + (arg1)->SetData((void const *)arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VertexBuffer_GetSize(void * jarg1) { + unsigned long jresult ; + Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ; + std::size_t result; + + arg1 = (Dali::VertexBuffer *)jarg1; + { + try { + result = ((Dali::VertexBuffer const *)arg1)->GetSize(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() { + void * jresult ; + Dali::Geometry result; + + { + try { + result = Dali::Geometry::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Geometry((const Dali::Geometry &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() { + void * jresult ; + Dali::Geometry *result = 0 ; + + { + try { + result = (Dali::Geometry *)new Dali::Geometry(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) { + Dali::Geometry *arg1 = (Dali::Geometry *) 0 ; + + arg1 = (Dali::Geometry *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Geometry *arg1 = 0 ; + Dali::Geometry *result = 0 ; + + arg1 = (Dali::Geometry *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Geometry 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::Geometry::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Geometry((const Dali::Geometry &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Geometry *arg1 = (Dali::Geometry *) 0 ; + Dali::Geometry *arg2 = 0 ; + Dali::Geometry *result = 0 ; + + arg1 = (Dali::Geometry *)jarg1; + arg2 = (Dali::Geometry *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) { + unsigned long jresult ; + Dali::Geometry *arg1 = (Dali::Geometry *) 0 ; + Dali::VertexBuffer *arg2 = 0 ; + std::size_t result; + + arg1 = (Dali::Geometry *)jarg1; + arg2 = (Dali::VertexBuffer *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer & type is null", 0); + return 0; + } + { + try { + result = (arg1)->AddVertexBuffer(*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) { + unsigned long jresult ; + Dali::Geometry *arg1 = (Dali::Geometry *) 0 ; + std::size_t result; + + arg1 = (Dali::Geometry *)jarg1; + { + try { + result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) { + Dali::Geometry *arg1 = (Dali::Geometry *) 0 ; + std::size_t arg2 ; + + arg1 = (Dali::Geometry *)jarg1; + arg2 = (std::size_t)jarg2; + { + try { + (arg1)->RemoveVertexBuffer(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) { + Dali::Geometry *arg1 = (Dali::Geometry *) 0 ; + unsigned short *arg2 = (unsigned short *) 0 ; + size_t arg3 ; + + arg1 = (Dali::Geometry *)jarg1; + arg2 = jarg2; + arg3 = (size_t)jarg3; + { + try { + (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + + + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) { + Dali::Geometry *arg1 = (Dali::Geometry *) 0 ; + Dali::Geometry::Type arg2 ; + + arg1 = (Dali::Geometry *)jarg1; + arg2 = (Dali::Geometry::Type)jarg2; + { + try { + (arg1)->SetType(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) { + int jresult ; + Dali::Geometry *arg1 = (Dali::Geometry *) 0 ; + Dali::Geometry::Type result; + + arg1 = (Dali::Geometry *)jarg1; + { + try { + result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() { + void * jresult ; + Dali::Shader::Hint *result = 0 ; + + { + try { + result = (Dali::Shader::Hint *)new Dali::Shader::Hint(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) { + Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ; + + arg1 = (Dali::Shader::Hint *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() { + int jresult ; + int result; + + result = (int)Dali::Shader::Property::PROGRAM; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() { + void * jresult ; + Dali::Shader::Property *result = 0 ; + + { + try { + result = (Dali::Shader::Property *)new Dali::Shader::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) { + Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ; + + arg1 = (Dali::Shader::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) { + void * jresult ; + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + Dali::Shader::Hint::Value arg3 ; + Dali::Shader result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Shader::Hint::Value)jarg3; + { + try { + result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Shader((const Dali::Shader &)result); + + //argout typemap for const std::string& + + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) { + void * jresult ; + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + Dali::Shader result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Shader((const Dali::Shader &)result); + + //argout typemap for const std::string& + + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() { + void * jresult ; + Dali::Shader *result = 0 ; + + { + try { + result = (Dali::Shader *)new Dali::Shader(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) { + Dali::Shader *arg1 = (Dali::Shader *) 0 ; + + arg1 = (Dali::Shader *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Shader *arg1 = 0 ; + Dali::Shader *result = 0 ; + + arg1 = (Dali::Shader *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Shader 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::Shader::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Shader((const Dali::Shader &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Shader *arg1 = (Dali::Shader *) 0 ; + Dali::Shader *arg2 = 0 ; + Dali::Shader *result = 0 ; + + arg1 = (Dali::Shader *)jarg1; + arg2 = (Dali::Shader *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::DEPTH_INDEX; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::FACE_CULLING_MODE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::BLEND_MODE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::BLEND_COLOR; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::DEPTH_FUNCTION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::RENDER_MODE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::STENCIL_FUNCTION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::STENCIL_MASK; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() { + int jresult ; + int result; + + result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() { + void * jresult ; + Dali::Renderer::Property *result = 0 ; + + { + try { + result = (Dali::Renderer::Property *)new Dali::Renderer::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) { + Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ; + + arg1 = (Dali::Renderer::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Geometry *arg1 = 0 ; + Dali::Shader *arg2 = 0 ; + Dali::Renderer result; + + arg1 = (Dali::Geometry *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0); + return 0; + } + arg2 = (Dali::Shader *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0); + return 0; + } + { + try { + result = Dali::Renderer::New(*arg1,*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Renderer((const Dali::Renderer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() { + void * jresult ; + Dali::Renderer *result = 0 ; + + { + try { + result = (Dali::Renderer *)new Dali::Renderer(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) { + Dali::Renderer *arg1 = (Dali::Renderer *) 0 ; + + arg1 = (Dali::Renderer *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Renderer *arg1 = 0 ; + Dali::Renderer *result = 0 ; + + arg1 = (Dali::Renderer *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Renderer 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::Renderer::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Renderer((const Dali::Renderer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Renderer *arg1 = (Dali::Renderer *) 0 ; + Dali::Renderer *arg2 = 0 ; + Dali::Renderer *result = 0 ; + + arg1 = (Dali::Renderer *)jarg1; + arg2 = (Dali::Renderer *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) { + Dali::Renderer *arg1 = (Dali::Renderer *) 0 ; + Dali::Geometry *arg2 = 0 ; + + arg1 = (Dali::Renderer *)jarg1; + arg2 = (Dali::Geometry *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0); + return ; + } + { + try { + (arg1)->SetGeometry(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) { + void * jresult ; + Dali::Renderer *arg1 = (Dali::Renderer *) 0 ; + Dali::Geometry result; + + arg1 = (Dali::Renderer *)jarg1; + { + try { + result = ((Dali::Renderer const *)arg1)->GetGeometry(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Geometry((const Dali::Geometry &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) { + Dali::Renderer *arg1 = (Dali::Renderer *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = (Dali::Renderer *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + { + try { + (arg1)->SetIndexRange(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) { + Dali::Renderer *arg1 = (Dali::Renderer *) 0 ; + Dali::TextureSet *arg2 = 0 ; + + arg1 = (Dali::Renderer *)jarg1; + arg2 = (Dali::TextureSet *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0); + return ; + } + { + try { + (arg1)->SetTextures(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) { + void * jresult ; + Dali::Renderer *arg1 = (Dali::Renderer *) 0 ; + Dali::TextureSet result; + + arg1 = (Dali::Renderer *)jarg1; + { + try { + result = ((Dali::Renderer const *)arg1)->GetTextures(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::TextureSet((const Dali::TextureSet &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) { + Dali::Renderer *arg1 = (Dali::Renderer *) 0 ; + Dali::Shader *arg2 = 0 ; + + arg1 = (Dali::Renderer *)jarg1; + arg2 = (Dali::Shader *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0); + return ; + } + { + try { + (arg1)->SetShader(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) { + void * jresult ; + Dali::Renderer *arg1 = (Dali::Renderer *) 0 ; + Dali::Shader result; + + arg1 = (Dali::Renderer *)jarg1; + { + try { + result = ((Dali::Renderer const *)arg1)->GetShader(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Shader((const Dali::Shader &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() { + void * jresult ; + Dali::FrameBuffer::Attachment *result = 0 ; + + { + try { + result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) { + Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ; + + arg1 = (Dali::FrameBuffer::Attachment *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) { + void * jresult ; + unsigned int arg1 ; + unsigned int arg2 ; + unsigned int arg3 ; + Dali::FrameBuffer result; + + arg1 = (unsigned int)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (unsigned int)jarg3; + { + try { + result = Dali::FrameBuffer::New(arg1,arg2,static_cast(arg3)); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() { + void * jresult ; + Dali::FrameBuffer *result = 0 ; + + { + try { + result = (Dali::FrameBuffer *)new Dali::FrameBuffer(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) { + Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ; + + arg1 = (Dali::FrameBuffer *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) { + void * jresult ; + Dali::FrameBuffer *arg1 = 0 ; + Dali::FrameBuffer *result = 0 ; + + arg1 = (Dali::FrameBuffer *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0); + return 0; + } + { + try { + result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::FrameBuffer 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::FrameBuffer::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ; + Dali::FrameBuffer *arg2 = 0 ; + Dali::FrameBuffer *result = 0 ; + + arg1 = (Dali::FrameBuffer *)jarg1; + arg2 = (Dali::FrameBuffer *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0); + return 0; + } + { + try { + result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) { + Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ; + Dali::Texture *arg2 = 0 ; + + arg1 = (Dali::FrameBuffer *)jarg1; + arg2 = (Dali::Texture *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0); + return ; + } + { + try { + (arg1)->AttachColorTexture(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) { + Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ; + Dali::Texture *arg2 = 0 ; + unsigned int arg3 ; + unsigned int arg4 ; + + arg1 = (Dali::FrameBuffer *)jarg1; + arg2 = (Dali::Texture *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0); + return ; + } + arg3 = (unsigned int)jarg3; + arg4 = (unsigned int)jarg4; + { + try { + (arg1)->AttachColorTexture(*arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) { + void * jresult ; + Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ; + Dali::Texture result; + + arg1 = (Dali::FrameBuffer *)jarg1; + { + try { + result = (arg1)->GetColorTexture(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Texture((const Dali::Texture &)result); + return jresult; +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_FrameBuffer_GenerateUrl(void *jFrameBuffer, int pixelFormat, int width, int height) +{ + void *jresult; + Dali::Toolkit::ImageUrl result; + Dali::FrameBuffer *frameBuffer = (Dali::FrameBuffer*)jFrameBuffer;; + + if (!frameBuffer) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer is null", 0); + return 0; + } + { + try + { + result = Dali::Toolkit::Image::GenerateUrl((const Dali::FrameBuffer&)*frameBuffer, (Pixel::Format)pixelFormat, (uint32_t)width, (uint32_t)height); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() { + void * jresult ; + Dali::RenderTaskList *result = 0 ; + + { + try { + result = (Dali::RenderTaskList *)new Dali::RenderTaskList(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::RenderTaskList 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::RenderTaskList::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) { + Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ; + + arg1 = (Dali::RenderTaskList *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) { + void * jresult ; + Dali::RenderTaskList *arg1 = 0 ; + Dali::RenderTaskList *result = 0 ; + + arg1 = (Dali::RenderTaskList *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0); + return 0; + } + { + try { + result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ; + Dali::RenderTaskList *arg2 = 0 ; + Dali::RenderTaskList *result = 0 ; + + arg1 = (Dali::RenderTaskList *)jarg1; + arg2 = (Dali::RenderTaskList *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0); + return 0; + } + { + try { + result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) { + void * jresult ; + Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ; + Dali::RenderTask result; + + arg1 = (Dali::RenderTaskList *)jarg1; + { + try { + result = (arg1)->CreateTask(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::RenderTask((const Dali::RenderTask &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) { + Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ; + Dali::RenderTask arg2 ; + Dali::RenderTask *argp2 ; + + arg1 = (Dali::RenderTaskList *)jarg1; + argp2 = (Dali::RenderTask *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->RemoveTask(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +//// ===============================================end part 1 ================= + +//// ========================= part 2 =============================== + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) { + unsigned int jresult ; + Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ; + unsigned int result; + + arg1 = (Dali::RenderTaskList *)jarg1; + { + try { + result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) { + void * jresult ; + Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ; + unsigned int arg2 ; + Dali::RenderTask result; + + arg1 = (Dali::RenderTaskList *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::RenderTask((const Dali::RenderTask &)result); + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() { + int jresult ; + int result; + + result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() { + int jresult ; + int result; + + result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() { + int jresult ; + int result; + + result = (int)Dali::RenderTask::Property::CLEAR_COLOR; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() { + int jresult ; + int result; + + result = (int)Dali::RenderTask::Property::REQUIRES_SYNC; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() { + void * jresult ; + Dali::RenderTask::Property *result = 0 ; + + { + try { + result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) { + Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ; + + arg1 = (Dali::RenderTask::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() { + void * jresult ; + bool (*result)(Dali::Vector2 &) = 0 ; + + result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() { + void * jresult ; + bool (*result)(Dali::Vector2 &) = 0 ; + + result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() { + bool jresult ; + bool result; + + result = (bool)Dali::RenderTask::DEFAULT_EXCLUSIVE; + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() { + bool jresult ; + bool result; + + result = (bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED; + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() { + void * jresult ; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() { + bool jresult ; + bool result; + + result = (bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED; + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() { + bool jresult ; + bool result; + + result = (bool)Dali::RenderTask::DEFAULT_CULL_MODE; + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() { + unsigned int jresult ; + unsigned int result; + + result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE; + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() { + void * jresult ; + Dali::RenderTask *result = 0 ; + + { + try { + result = (Dali::RenderTask *)new Dali::RenderTask(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::RenderTask 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::RenderTask::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::RenderTask((const Dali::RenderTask &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) { + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + + arg1 = (Dali::RenderTask *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) { + void * jresult ; + Dali::RenderTask *arg1 = 0 ; + Dali::RenderTask *result = 0 ; + + arg1 = (Dali::RenderTask *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0); + return 0; + } + { + try { + result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::RenderTask *arg2 = 0 ; + Dali::RenderTask *result = 0 ; + + arg1 = (Dali::RenderTask *)jarg1; + arg2 = (Dali::RenderTask *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0); + return 0; + } + { + try { + result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) { + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::RenderTask *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetSourceActor(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) { + void * jresult ; + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::Actor result; + + arg1 = (Dali::RenderTask *)jarg1; + { + try { + result = ((Dali::RenderTask const *)arg1)->GetSourceActor(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, bool jarg2) { + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + bool arg2 ; + + arg1 = (Dali::RenderTask *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->SetExclusive(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) { + bool jresult ; + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + bool result; + + arg1 = (Dali::RenderTask *)jarg1; + { + try { + result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, bool jarg2) { + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + bool arg2 ; + + arg1 = (Dali::RenderTask *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->SetInputEnabled(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) { + bool jresult ; + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + bool result; + + arg1 = (Dali::RenderTask *)jarg1; + { + try { + result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) { + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::CameraActor arg2 ; + Dali::CameraActor *argp2 ; + + arg1 = (Dali::RenderTask *)jarg1; + argp2 = (Dali::CameraActor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetCameraActor(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) { + void * jresult ; + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::CameraActor result; + + arg1 = (Dali::RenderTask *)jarg1; + { + try { + result = ((Dali::RenderTask const *)arg1)->GetCameraActor(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::CameraActor((const Dali::CameraActor &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) { + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::FrameBuffer arg2 ; + Dali::FrameBuffer *argp2 ; + + arg1 = (Dali::RenderTask *)jarg1; + argp2 = (Dali::FrameBuffer *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetFrameBuffer(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) { + void * jresult ; + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::FrameBuffer result; + + arg1 = (Dali::RenderTask *)jarg1; + { + try { + result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) { + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ; + + arg1 = (Dali::RenderTask *)jarg1; + arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2; + { + try { + (arg1)->SetScreenToFrameBufferFunction(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) { + void * jresult ; + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::RenderTask::ScreenToFrameBufferFunction result; + + arg1 = (Dali::RenderTask *)jarg1; + { + try { + result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) { + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::RenderTask *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetScreenToFrameBufferMappingActor(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) { + void * jresult ; + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::Actor result; + + arg1 = (Dali::RenderTask *)jarg1; + { + try { + result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) { + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::Vector2 arg2 ; + Dali::Vector2 *argp2 ; + + arg1 = (Dali::RenderTask *)jarg1; + argp2 = (Dali::Vector2 *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetViewportPosition(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) { + void * jresult ; + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::RenderTask *)jarg1; + { + try { + result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) { + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::Vector2 arg2 ; + Dali::Vector2 *argp2 ; + + arg1 = (Dali::RenderTask *)jarg1; + argp2 = (Dali::Vector2 *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetViewportSize(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) { + void * jresult ; + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::RenderTask *)jarg1; + { + try { + result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) { + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::Viewport arg2 ; + Dali::Viewport *argp2 ; + + arg1 = (Dali::RenderTask *)jarg1; + argp2 = (Dali::Viewport *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetViewport(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) { + void * jresult ; + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::Viewport result; + + arg1 = (Dali::RenderTask *)jarg1; + { + try { + result = ((Dali::RenderTask const *)arg1)->GetViewport(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Viewport((const Dali::Viewport &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) { + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::Vector4 *arg2 = 0 ; + + arg1 = (Dali::RenderTask *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetClearColor((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) { + void * jresult ; + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::Vector4 result; + + arg1 = (Dali::RenderTask *)jarg1; + { + try { + result = ((Dali::RenderTask const *)arg1)->GetClearColor(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, bool jarg2) { + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + bool arg2 ; + + arg1 = (Dali::RenderTask *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->SetClearEnabled(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) { + bool jresult ; + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + bool result; + + arg1 = (Dali::RenderTask *)jarg1; + { + try { + result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, bool jarg2) { + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + bool arg2 ; + + arg1 = (Dali::RenderTask *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->SetCullMode(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) { + bool jresult ; + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + bool result; + + arg1 = (Dali::RenderTask *)jarg1; + { + try { + result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) { + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::RenderTask *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + (arg1)->SetRefreshRate(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) { + unsigned int jresult ; + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + unsigned int result; + + arg1 = (Dali::RenderTask *)jarg1; + { + try { + result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) { + bool jresult ; + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::Vector3 *arg2 = 0 ; + float *arg3 = 0 ; + float *arg4 = 0 ; + bool result; + + arg1 = (Dali::RenderTask *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + arg3 = (float *)jarg3; + arg4 = (float *)jarg4; + { + try { + result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) { + bool jresult ; + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::Actor arg2 ; + float arg3 ; + float arg4 ; + float *arg5 = 0 ; + float *arg6 = 0 ; + Dali::Actor *argp2 ; + bool result; + + arg1 = (Dali::RenderTask *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg2 = *argp2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + arg5 = (float *)jarg5; + arg6 = (float *)jarg6; + { + try { + result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) { + void * jresult ; + Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; + Dali::RenderTask::RenderTaskSignalType *result = 0 ; + + arg1 = (Dali::RenderTask *)jarg1; + { + try { + result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) { + void * jresult ; + int arg1 ; + Dali::PointState::Type arg2 ; + float arg3 ; + float arg4 ; + Dali::TouchPoint *result = 0 ; + + arg1 = (int)jarg1; + arg2 = (Dali::PointState::Type)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + { + try { + result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) { + void * jresult ; + int arg1 ; + Dali::PointState::Type arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + Dali::TouchPoint *result = 0 ; + + arg1 = (int)jarg1; + arg2 = (Dali::PointState::Type)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + arg5 = (float)jarg5; + arg6 = (float)jarg6; + { + try { + result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) { + Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; + + arg1 = (Dali::TouchPoint *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) { + Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; + int arg2 ; + + arg1 = (Dali::TouchPoint *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->deviceId = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) { + int jresult ; + Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; + int result; + + arg1 = (Dali::TouchPoint *)jarg1; + result = (int) ((arg1)->deviceId); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) { + Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; + Dali::PointState::Type arg2 ; + + arg1 = (Dali::TouchPoint *)jarg1; + arg2 = (Dali::PointState::Type)jarg2; + if (arg1) (arg1)->state = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) { + int jresult ; + Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; + Dali::PointState::Type result; + + arg1 = (Dali::TouchPoint *)jarg1; + result = (Dali::PointState::Type) ((arg1)->state); + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) { + Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; + Dali::Actor *arg2 = (Dali::Actor *) 0 ; + + arg1 = (Dali::TouchPoint *)jarg1; + arg2 = (Dali::Actor *)jarg2; + if (arg1) (arg1)->hitActor = *arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) { + void * jresult ; + Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; + Dali::Actor *result = 0 ; + + arg1 = (Dali::TouchPoint *)jarg1; + result = (Dali::Actor *)& ((arg1)->hitActor); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) { + Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; + Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ; + + arg1 = (Dali::TouchPoint *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (arg1) (arg1)->local = *arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) { + void * jresult ; + Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::TouchPoint *)jarg1; + result = (Dali::Vector2 *)& ((arg1)->local); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) { + Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; + Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ; + + arg1 = (Dali::TouchPoint *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (arg1) (arg1)->screen = *arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) { + void * jresult ; + Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::TouchPoint *)jarg1; + result = (Dali::Vector2 *)& ((arg1)->screen); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() { + void * jresult ; + Dali::TouchEvent *result = 0 ; + + { + try { + result = (Dali::TouchEvent *)new Dali::TouchEvent(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) { + void * jresult ; + Dali::TouchEvent *arg1 = 0 ; + Dali::TouchEvent *result = 0 ; + + arg1 = (Dali::TouchEvent *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0); + return 0; + } + { + try { + result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) { + Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; + + arg1 = (Dali::TouchEvent *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; + Dali::TouchEvent *arg2 = 0 ; + Dali::TouchEvent *result = 0 ; + + arg1 = (Dali::TouchEvent *)jarg1; + arg2 = (Dali::TouchEvent *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0); + return 0; + } + { + try { + result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) { + unsigned long jresult ; + Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; + unsigned long result; + + arg1 = (Dali::TouchEvent *)jarg1; + { + try { + result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) { + unsigned long jresult ; + Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; + std::size_t result; + + arg1 = (Dali::TouchEvent *)jarg1; + { + try { + result = ((Dali::TouchEvent const *)arg1)->GetPointCount(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) { + int jresult ; + Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; + std::size_t arg2 ; + int32_t result; + + arg1 = (Dali::TouchEvent *)jarg1; + arg2 = (std::size_t)jarg2; + { + try { + result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) { + int jresult ; + Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; + std::size_t arg2 ; + Dali::PointState::Type result; + + arg1 = (Dali::TouchEvent *)jarg1; + arg2 = (std::size_t)jarg2; + { + try { + result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; + std::size_t arg2 ; + Dali::Actor result; + + arg1 = (Dali::TouchEvent *)jarg1; + arg2 = (std::size_t)jarg2; + { + try { + result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; + std::size_t arg2 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::TouchEvent *)jarg1; + arg2 = (std::size_t)jarg2; + { + try { + result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; + std::size_t arg2 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::TouchEvent *)jarg1; + arg2 = (std::size_t)jarg2; + { + try { + result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) { + float jresult ; + Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; + std::size_t arg2 ; + float result; + + arg1 = (Dali::TouchEvent *)jarg1; + arg2 = (std::size_t)jarg2; + { + try { + result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; + std::size_t arg2 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::TouchEvent *)jarg1; + arg2 = (std::size_t)jarg2; + { + try { + result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) { + float jresult ; + Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; + std::size_t arg2 ; + float result; + + arg1 = (Dali::TouchEvent *)jarg1; + arg2 = (std::size_t)jarg2; + { + try { + result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; + std::size_t arg2 ; + Dali::Degree result; + + arg1 = (Dali::TouchEvent *)jarg1; + arg2 = (std::size_t)jarg2; + { + try { + result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Degree((const Dali::Degree &)result); + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceClass(void * jarg1, unsigned long jarg2) { + int jresult ; + Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; + std::size_t arg2 ; + Dali::Device::Class::Type result; + + arg1 = (Dali::TouchEvent *)jarg1; + arg2 = (std::size_t)jarg2; + { + try { + result = ((Dali::TouchEvent const *)arg1)->GetDeviceClass(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceSubclass(void * jarg1, unsigned long jarg2) { + int jresult ; + Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; + std::size_t arg2 ; + Dali::Device::Subclass::Type result; + + arg1 = (Dali::TouchEvent *)jarg1; + arg2 = (std::size_t)jarg2; + { + try { + result = ((Dali::TouchEvent const *)arg1)->GetDeviceSubclass(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) { + int jresult ; + Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; + std::size_t arg2 ; + Dali::MouseButton::Type result; + + arg1 = (Dali::TouchEvent *)jarg1; + arg2 = (std::size_t)jarg2; + { + try { + result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = static_cast< int >(result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() { + void * jresult ; + Dali::GestureDetector *result = 0 ; + + { + try { + result = (Dali::GestureDetector *)new Dali::GestureDetector(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::GestureDetector 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::GestureDetector::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) { + Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ; + + arg1 = (Dali::GestureDetector *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) { + void * jresult ; + Dali::GestureDetector *arg1 = 0 ; + Dali::GestureDetector *result = 0 ; + + arg1 = (Dali::GestureDetector *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0); + return 0; + } + { + try { + result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ; + Dali::GestureDetector *arg2 = 0 ; + Dali::GestureDetector *result = 0 ; + + arg1 = (Dali::GestureDetector *)jarg1; + arg2 = (Dali::GestureDetector *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0); + return 0; + } + { + try { + result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) { + Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::GestureDetector *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->Attach(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) { + Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::GestureDetector *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->Detach(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) { + Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ; + + arg1 = (Dali::GestureDetector *)jarg1; + { + try { + (arg1)->DetachAll(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) { + unsigned long jresult ; + Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ; + size_t result; + + arg1 = (Dali::GestureDetector *)jarg1; + { + try { + result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ; + size_t arg2 ; + Dali::Actor result; + + arg1 = (Dali::GestureDetector *)jarg1; + arg2 = (size_t)jarg2; + { + try { + result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) { + void * jresult ; + Dali::Gesture *arg1 = 0 ; + Dali::Gesture *result = 0 ; + + arg1 = (Dali::Gesture *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Gesture *arg1 = (Dali::Gesture *) 0 ; + Dali::Gesture *arg2 = 0 ; + Dali::Gesture *result = 0 ; + + arg1 = (Dali::Gesture *)jarg1; + arg2 = (Dali::Gesture *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) { + Dali::Gesture *arg1 = (Dali::Gesture *) 0 ; + + arg1 = (Dali::Gesture *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) { + int jresult ; + Dali::Gesture *arg1 = (Dali::Gesture *) 0 ; + Dali::GestureType::Value result; + + arg1 = (Dali::Gesture *)jarg1; + result = (Dali::GestureType::Value) ((arg1)->GetType()); + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) { + int jresult ; + Dali::Gesture *arg1 = (Dali::Gesture *) 0 ; + Dali::GestureState result; + + arg1 = (Dali::Gesture *)jarg1; + result = (Dali::GestureState) ((arg1)->GetState()); + jresult = (int)result; + return jresult; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) { + unsigned int jresult ; + Dali::Gesture *arg1 = (Dali::Gesture *) 0 ; + unsigned int result; + + arg1 = (Dali::Gesture *)jarg1; + result = (unsigned int) ((arg1)->GetTime()); + jresult = result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_sourceType_get(void * gesture) { + int jresult ; + Dali::Gesture *jGesture = (Dali::Gesture *) gesture; + Dali::GestureSourceType result; + + if (!jGesture) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0); + return 0; + } + { + try { + result = (Dali::GestureSourceType)jGesture->GetSourceType(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_sourceData_get(void * gesture) { + int jresult ; + Dali::Gesture *jGesture = (Dali::Gesture *) gesture; + Dali::GestureSourceData result; + + if (!jGesture) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::gesture const & type is null", 0); + return 0; + } + { + try { + result = (Dali::GestureSourceData)jGesture->GetSourceData(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() { + void * jresult ; + Dali::HoverEvent *result = 0 ; + + { + try { + result = (Dali::HoverEvent *)new Dali::HoverEvent(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) { + void * jresult ; + Dali::HoverEvent *arg1 = 0 ; + Dali::HoverEvent *result = 0 ; + + arg1 = (Dali::HoverEvent *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0); + return 0; + } + { + try { + result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) { + Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ; + + arg1 = (Dali::HoverEvent *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ; + Dali::HoverEvent *arg2 = 0 ; + Dali::HoverEvent *result = 0 ; + + arg1 = (Dali::HoverEvent *)jarg1; + arg2 = (Dali::HoverEvent *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0); + return 0; + } + { + try { + result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_New(unsigned int jarg1) { + void * jresult ; + unsigned int arg1 ; + Dali::HoverEvent result; + + arg1 = (unsigned int)jarg1; + { + try { + result = DevelHoverEvent::New(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::HoverEvent((const Dali::HoverEvent &)result); + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) { + unsigned long jresult ; + Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ; + unsigned long result; + + arg1 = (Dali::HoverEvent *)jarg1; + { + try { + result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) { + unsigned long jresult ; + Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ; + std::size_t result; + + arg1 = (Dali::HoverEvent *)jarg1; + { + try { + result = ((Dali::HoverEvent const *)arg1)->GetPointCount(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) { + int jresult ; + Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ; + std::size_t arg2 ; + int32_t result; + + arg1 = (Dali::HoverEvent *)jarg1; + arg2 = (std::size_t)jarg2; + { + try { + result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) { + int jresult ; + Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ; + std::size_t arg2 ; + Dali::PointState::Type result; + + arg1 = (Dali::HoverEvent *)jarg1; + arg2 = (std::size_t)jarg2; + { + try { + result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ; + std::size_t arg2 ; + Dali::Actor result; + + arg1 = (Dali::HoverEvent *)jarg1; + arg2 = (std::size_t)jarg2; + { + try { + result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ; + std::size_t arg2 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::HoverEvent *)jarg1; + arg2 = (std::size_t)jarg2; + { + try { + result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ; + std::size_t arg2 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::HoverEvent *)jarg1; + arg2 = (std::size_t)jarg2; + { + try { + result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() { + void * jresult ; + Dali::KeyEvent *result = 0 ; + + { + try { + result = (Dali::KeyEvent *)new Dali::KeyEvent(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(void * jarg1) { + void * jresult ; + Dali::KeyEvent *arg1 = 0 ; + Dali::KeyEvent *result = 0 ; + + arg1 = (Dali::KeyEvent *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0); + return 0; + } + { + try { + result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ; + Dali::KeyEvent *arg2 = 0 ; + Dali::KeyEvent *result = 0 ; + + arg1 = (Dali::KeyEvent *)jarg1; + arg2 = (Dali::KeyEvent *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0); + return 0; + } + { + try { + result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_New(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) { + void * jresult ; + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + int arg3 ; + int arg4 ; + unsigned long arg5 ; + Dali::KeyEvent::State *arg6 = 0 ; + Dali::KeyEvent::State temp6 ; + Dali::KeyEvent result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (int)jarg3; + arg4 = (int)jarg4; + arg5 = (unsigned long)jarg5; + temp6 = (Dali::KeyEvent::State)jarg6; + arg6 = &temp6; + { + try { + result = DevelKeyEvent::New((std::string const &)*arg1, "", (std::string const &)*arg2, arg3, arg4, arg5, (Dali::KeyEvent::State const &)*arg6, "", "", Device::Class::NONE, Device::Subclass::NONE); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result); + + //argout typemap for const std::string& + + + //argout typemap for const std::string& + + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) { + Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ; + + arg1 = (Dali::KeyEvent *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) { + bool jresult ; + Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ; + bool result; + + arg1 = (Dali::KeyEvent *)jarg1; + { + try { + result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) { + bool jresult ; + Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ; + bool result; + + arg1 = (Dali::KeyEvent *)jarg1; + { + try { + result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) { + bool jresult ; + Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ; + bool result; + + arg1 = (Dali::KeyEvent *)jarg1; + { + try { + result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) { + Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ; + std::string *arg2 = 0 ; + + argp1 = (Dali::KeyEvent *) jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0); + return ; + } + + Dali::KeyEvent arg1 = *argp1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + + { + try { + Dali::DevelKeyEvent::SetKeyName(arg1, (std::string const &)*arg2); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return ; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return ; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) { + char * jresult ; + + if( jarg1 == NULL ) + { + jresult = SWIG_csharp_string_callback( "" ); + } + else + { + Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0; + std::string *result = 0; + std::string str = ""; + + arg1 = ( Dali::KeyEvent * )jarg1; + { + try { + str = ((Dali::KeyEvent const *)arg1)->GetKeyName(); + result = (std::string *) &str; + jresult = SWIG_csharp_string_callback(result->c_str()); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + } + + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) { + Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ; + std::string *arg2 = 0 ; + + argp1 = (Dali::KeyEvent *) jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0); + return ; + } + + Dali::KeyEvent arg1 = *argp1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + + { + try { + Dali::DevelKeyEvent::SetKeyString(arg1, (std::string const &)*arg2); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return ; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return ; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) { + char * jresult ; + + Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0; + std::string *result = 0; + std::string str = ""; + arg1 = ( Dali::KeyEvent * )jarg1; + { + try { + str = ((Dali::KeyEvent const *)arg1)->GetKeyString(); + result = (std::string *) &str; + jresult = SWIG_csharp_string_callback(result->c_str()); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) { + Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ; + int arg2 ; + + argp1 = (Dali::KeyEvent *) jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0); + return ; + } + + Dali::KeyEvent arg1 = *argp1; + arg2 = (int)jarg2; + { + try { + Dali::DevelKeyEvent::SetKeyCode(arg1, arg2); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return ; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return ; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) { + int jresult ; + Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0; + int result; + + arg1 = (Dali::KeyEvent *)jarg1; + { + try { + result = (int)((Dali::KeyEvent const *)arg1)->GetKeyCode(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) { + Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ; + int arg2 ; + + argp1 = (Dali::KeyEvent *) jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0); + return ; + } + + Dali::KeyEvent arg1 = *argp1; + arg2 = (int)jarg2; + { + try { + Dali::DevelKeyEvent::SetKeyModifier(arg1, arg2); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return ; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return ; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) { + int jresult ; + Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0; + int result; + + arg1 = (Dali::KeyEvent *)jarg1; + { + try { + result = (int)((Dali::KeyEvent const *)arg1)->GetKeyModifier(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) { + Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ; + unsigned long arg2 ; + + argp1 = (Dali::KeyEvent *) jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0); + return ; + } + + Dali::KeyEvent arg1 = *argp1; + arg2 = (int)jarg2; + { + try { + Dali::DevelKeyEvent::SetTime(arg1, arg2); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return ; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return ; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) { + unsigned long jresult ; + Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0; + unsigned long result; + + arg1 = (Dali::KeyEvent *)jarg1; + { + try { + result = (int)((Dali::KeyEvent const *)arg1)->GetTime(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) { + Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0; + Dali::KeyEvent::State arg2; + + argp1 = (Dali::KeyEvent *) jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0); + return ; + } + + Dali::KeyEvent arg1 = *argp1; + arg2 = (Dali::KeyEvent::State)jarg2; + { + try { + Dali::DevelKeyEvent::SetState(arg1, arg2); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return ; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return ; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; + }; + } + } +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) { + int jresult ; + Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0; + Dali::KeyEvent::State result; + + arg1 = (Dali::KeyEvent *)jarg1; + { + try { + result = (Dali::KeyEvent::State)((Dali::KeyEvent const *)arg1)->GetState(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + jresult = (int)result; + return jresult; + +} + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) { + char * jresult ; + + Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0; + std::string *result = 0; + std::string str = ""; + + arg1 = ( Dali::KeyEvent * )jarg1; + { + try { + str = ((Dali::KeyEvent const *)arg1)->GetLogicalKey(); + result = (std::string *) &str; + jresult = SWIG_csharp_string_callback(result->c_str()); + } CALL_CATCH_EXCEPTION(0); + } + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() { + void * jresult ; + Dali::LongPressGestureDetector *result = 0 ; + + { + try { + result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() { + void * jresult ; + Dali::LongPressGestureDetector result; + + { + try { + result = Dali::LongPressGestureDetector::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) { + void * jresult ; + unsigned int arg1 ; + Dali::LongPressGestureDetector result; + + arg1 = (unsigned int)jarg1; + { + try { + result = Dali::LongPressGestureDetector::New(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) { + void * jresult ; + unsigned int arg1 ; + unsigned int arg2 ; + Dali::LongPressGestureDetector result; + + arg1 = (unsigned int)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = Dali::LongPressGestureDetector::New(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::LongPressGestureDetector 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::LongPressGestureDetector::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) { + Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ; + + arg1 = (Dali::LongPressGestureDetector *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) { + void * jresult ; + Dali::LongPressGestureDetector *arg1 = 0 ; + Dali::LongPressGestureDetector *result = 0 ; + + arg1 = (Dali::LongPressGestureDetector *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0); + return 0; + } + { + try { + result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ; + Dali::LongPressGestureDetector *arg2 = 0 ; + Dali::LongPressGestureDetector *result = 0 ; + + arg1 = (Dali::LongPressGestureDetector *)jarg1; + arg2 = (Dali::LongPressGestureDetector *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0); + return 0; + } + { + try { + result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) { + Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::LongPressGestureDetector *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + (arg1)->SetTouchesRequired(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) { + Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ; + unsigned int arg2 ; + unsigned int arg3 ; + + arg1 = (Dali::LongPressGestureDetector *)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (unsigned int)jarg3; + { + try { + (arg1)->SetTouchesRequired(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) { + unsigned int jresult ; + Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ; + unsigned int result; + + arg1 = (Dali::LongPressGestureDetector *)jarg1; + { + try { + result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) { + unsigned int jresult ; + Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ; + unsigned int result; + + arg1 = (Dali::LongPressGestureDetector *)jarg1; + { + try { + result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) { + void * jresult ; + Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ; + Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ; + + arg1 = (Dali::LongPressGestureDetector *)jarg1; + { + try { + result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0() { + void * jresult ; + Dali::LongPressGesture *result = 0 ; + + { + try { + result = (Dali::LongPressGesture *)new Dali::LongPressGesture(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_New(int jarg1) { + void * jresult ; + Dali::GestureState arg1 ; + Dali::LongPressGesture result; + + arg1 = (Dali::GestureState)jarg1; + { + try { + result = DevelLongPressGesture::New(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::LongPressGesture((const Dali::LongPressGesture &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) { + void * jresult ; + Dali::LongPressGesture *arg1 = 0 ; + Dali::LongPressGesture *result = 0 ; + + arg1 = (Dali::LongPressGesture *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0); + return 0; + } + { + try { + result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ; + Dali::LongPressGesture *arg2 = 0 ; + Dali::LongPressGesture *result = 0 ; + + arg1 = (Dali::LongPressGesture *)jarg1; + arg2 = (Dali::LongPressGesture *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0); + return 0; + } + { + try { + result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) { + Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ; + + arg1 = (Dali::LongPressGesture *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) { + unsigned int jresult ; + Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ; + unsigned int result; + + arg1 = (Dali::LongPressGesture *)jarg1; + result = (unsigned int) ((arg1)->GetNumberOfTouches()); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) { + void * jresult ; + Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::LongPressGesture *)jarg1; + { + try { + result = ((Dali::LongPressGesture const *)arg1)->GetScreenPoint(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) { + void * jresult ; + Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::LongPressGesture *)jarg1; + { + try { + result = ((Dali::LongPressGesture const *)arg1)->GetLocalPoint(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() { + void * jresult ; + Dali::WheelEvent *result = 0 ; + + { + try { + result = (Dali::WheelEvent *)new Dali::WheelEvent(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) { + void * jresult ; + Dali::WheelEvent *arg1 = 0 ; + Dali::WheelEvent *result = 0 ; + + arg1 = (Dali::WheelEvent *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0); + return 0; + } + { + try { + result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; + Dali::WheelEvent *arg2 = 0 ; + Dali::WheelEvent *result = 0 ; + + arg1 = (Dali::WheelEvent *)jarg1; + arg2 = (Dali::WheelEvent *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0); + return 0; + } + { + try { + result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) { + void * jresult ; + Dali::WheelEvent::Type arg1 ; + int arg2 ; + unsigned int arg3 ; + Dali::Vector2 arg4 ; + int arg5 ; + unsigned int arg6 ; + Dali::Vector2 *argp4 ; + Dali::WheelEvent result; + + arg1 = (Dali::WheelEvent::Type)jarg1; + arg2 = (int)jarg2; + arg3 = (unsigned int)jarg3; + argp4 = (Dali::Vector2 *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); + return 0; + } + arg4 = *argp4; + arg5 = (int)jarg5; + arg6 = (unsigned int)jarg6; + { + try { + result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) { + Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; + + arg1 = (Dali::WheelEvent *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) { + bool jresult ; + Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; + bool result; + + arg1 = (Dali::WheelEvent *)jarg1; + { + try { + result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) { + bool jresult ; + Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; + bool result; + + arg1 = (Dali::WheelEvent *)jarg1; + { + try { + result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) { + bool jresult ; + Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; + bool result; + + arg1 = (Dali::WheelEvent *)jarg1; + { + try { + result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) { + int jresult ; + Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; + Dali::WheelEvent::Type result; + + arg1 = (Dali::WheelEvent *)jarg1; + { + try { + result = ((Dali::WheelEvent const *)arg1)->GetType(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) { + int jresult ; + Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; + int result; + + arg1 = (Dali::WheelEvent *)jarg1; + { + try { + result = ((Dali::WheelEvent const *)arg1)->GetDirection(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) { + unsigned int jresult ; + Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; + unsigned int result; + + arg1 = (Dali::WheelEvent *)jarg1; + { + try { + result = ((Dali::WheelEvent const *)arg1)->GetModifiers(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) { + void * jresult ; + Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::WheelEvent *)jarg1; + { + try { + result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) { + int jresult ; + Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; + int result; + + arg1 = (Dali::WheelEvent *)jarg1; + { + try { + result = ((Dali::WheelEvent const *)arg1)->GetDelta(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) { + unsigned int jresult ; + Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; + unsigned int result; + + arg1 = (Dali::WheelEvent *)jarg1; + { + try { + result = ((Dali::WheelEvent const *)arg1)->GetTime(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + + jresult = result; + return jresult; +} + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) { + char * jresult ; + Dali::KeyEvent *arg1 = 0 ; + std::string result; + + arg1 = (Dali::KeyEvent *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0); + return 0; + } + { + try { + result = arg1->GetDeviceName(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback((&result)->c_str()); + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) { + int jresult ; + Dali::KeyEvent *arg1 = 0 ; + Dali::Device::Class::Type result; + + arg1 = (Dali::KeyEvent *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Device::Class::Type)arg1->GetDeviceClass(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) { + int jresult ; + Dali::KeyEvent *arg1 = 0 ; + Dali::Device::Subclass::Type result; + + arg1 = (Dali::KeyEvent *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() { + void * jresult ; + Dali::Stage result; + + { + try { + result = Dali::Stage::GetCurrent(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Stage((const Dali::Stage &)result); + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() { + bool jresult ; + bool result; + + { + try { + result = (bool)Dali::Stage::IsInstalled(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) { + void * jresult ; + Dali::Stage *arg1 = (Dali::Stage *) 0 ; + Dali::RenderTaskList result; + + arg1 = (Dali::Stage *)jarg1; + { + try { + result = ((Dali::Stage const *)arg1)->GetRenderTaskList(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) { + void * jresult ; + Dali::Stage *arg1 = (Dali::Stage *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::Stage *)jarg1; + { + try { + result = ((Dali::Stage const *)arg1)->GetDpi(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) { + Dali::Stage *arg1 = (Dali::Stage *) 0 ; + float arg2 ; + + arg1 = (Dali::Stage *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->KeepRendering(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) { + void * jresult ; + Dali::Stage *arg1 = (Dali::Stage *) 0 ; + Dali::Stage::KeyEventSignalType *result = 0 ; + + arg1 = (Dali::Stage *)jarg1; + { + try { + result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) { + void * jresult ; + Dali::Stage *arg1 = (Dali::Stage *) 0 ; + Dali::Stage::EventProcessingFinishedSignalType *result = 0 ; + + arg1 = (Dali::Stage *)jarg1; + { + try { + result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) { + void * jresult ; + Dali::Stage *arg1 = (Dali::Stage *) 0 ; + Dali::Stage::TouchEventSignalType *result = 0 ; + + arg1 = (Dali::Stage *)jarg1; + { + try { + result = (Dali::Stage::TouchEventSignalType *) &(arg1)->TouchedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) { + void * jresult ; + Dali::Stage *arg1 = (Dali::Stage *) 0 ; + Dali::Stage::WheelEventSignalType *result = 0 ; + + arg1 = (Dali::Stage *)jarg1; + { + try { + result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) { + void * jresult ; + Dali::Stage *arg1 = (Dali::Stage *) 0 ; + Dali::Stage::ContextStatusSignal *result = 0 ; + + arg1 = (Dali::Stage *)jarg1; + { + try { + result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) { + void * jresult ; + Dali::Stage *arg1 = (Dali::Stage *) 0 ; + Dali::Stage::ContextStatusSignal *result = 0 ; + + arg1 = (Dali::Stage *)jarg1; + { + try { + result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) { + void * jresult ; + Dali::Stage *arg1 = (Dali::Stage *) 0 ; + Dali::Stage::SceneCreatedSignalType *result = 0 ; + + arg1 = (Dali::Stage *)jarg1; + { + try { + result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) { + Dali::Stage *arg1 = (Dali::Stage *) 0 ; + Dali::DevelStage::Rendering arg2 ; + + arg1 = (Dali::Stage *)jarg1; + arg2 = (Dali::DevelStage::Rendering)jarg2; + { + try { + DevelStage::SetRenderingBehavior(*arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) { + + int jresult ; + int result ; + Dali::Stage *arg1 = (Dali::Stage *) 0 ; + + arg1 = (Dali::Stage *)jarg1; + { + try { + result = (int)(DevelStage::GetRenderingBehavior(*arg1)); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) { + Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ; + + arg1 = (Dali::RelayoutContainer *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) { + Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ; + Dali::Actor *arg2 = 0 ; + Dali::Vector2 *arg3 = 0 ; + + arg1 = (Dali::RelayoutContainer *)jarg1; + arg2 = (Dali::Actor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); + return ; + } + arg3 = (Dali::Vector2 *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + { + try { + (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) { + void * jresult ; + Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; + Dali::CustomActor result; + + arg1 = (Dali::CustomActorImpl *)jarg1; + { + try { + result = ((Dali::CustomActorImpl const *)arg1)->Self(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::CustomActor((const Dali::CustomActor &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) { + Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; + int arg2 ; + + arg1 = (Dali::CustomActorImpl *)jarg1; + arg2 = (int)jarg2; + { + try { + (arg1)->OnSceneConnection(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) { + Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; + + arg1 = (Dali::CustomActorImpl *)jarg1; + { + try { + (arg1)->OnSceneDisconnection(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) { + Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; + Dali::Actor *arg2 = 0 ; + + arg1 = (Dali::CustomActorImpl *)jarg1; + arg2 = (Dali::Actor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); + return ; + } + { + try { + (arg1)->OnChildAdd(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) { + Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; + Dali::Actor *arg2 = 0 ; + + arg1 = (Dali::CustomActorImpl *)jarg1; + arg2 = (Dali::Actor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); + return ; + } + { + try { + (arg1)->OnChildRemove(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) { + Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; + Dali::Property::Index arg2 ; + Dali::Property::Value arg3 ; + Dali::Property::Value *argp3 ; + + arg1 = (Dali::CustomActorImpl *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + argp3 = (Dali::Property::Value *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); + return ; + } + arg3 = *argp3; + { + try { + (arg1)->OnPropertySet(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) { + Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; + Dali::Vector3 *arg2 = 0 ; + + arg1 = (Dali::CustomActorImpl *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + { + try { + (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) { + Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; + Dali::Animation *arg2 = 0 ; + Dali::Vector3 *arg3 = 0 ; + + arg1 = (Dali::CustomActorImpl *)jarg1; + arg2 = (Dali::Animation *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0); + return ; + } + arg3 = (Dali::Vector3 *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + { + try { + (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) { + Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; + Dali::Vector2 *arg2 = 0 ; + Dali::RelayoutContainer *arg3 = 0 ; + + arg1 = (Dali::CustomActorImpl *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + arg3 = (Dali::RelayoutContainer *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0); + return ; + } + { + try { + (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) { + Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; + Dali::ResizePolicy::Type arg2 ; + Dali::Dimension::Type arg3 ; + + arg1 = (Dali::CustomActorImpl *)jarg1; + arg2 = (Dali::ResizePolicy::Type)jarg2; + arg3 = (Dali::Dimension::Type)jarg3; + { + try { + (arg1)->OnSetResizePolicy(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) { + void * jresult ; + Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; + Dali::Vector3 result; + + arg1 = (Dali::CustomActorImpl *)jarg1; + { + try { + result = (arg1)->GetNaturalSize(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) { + float jresult ; + Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; + Dali::Actor *arg2 = 0 ; + Dali::Dimension::Type arg3 ; + float result; + + arg1 = (Dali::CustomActorImpl *)jarg1; + arg2 = (Dali::Actor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); + return 0; + } + arg3 = (Dali::Dimension::Type)jarg3; + { + try { + result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) { + float jresult ; + Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; + float arg2 ; + float result; + + arg1 = (Dali::CustomActorImpl *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (float)(arg1)->GetHeightForWidth(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) { + float jresult ; + Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; + float arg2 ; + float result; + + arg1 = (Dali::CustomActorImpl *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (float)(arg1)->GetWidthForHeight(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) { + bool jresult ; + Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; + Dali::Dimension::Type arg2 ; + bool result; + + arg1 = (Dali::CustomActorImpl *)jarg1; + arg2 = (Dali::Dimension::Type)jarg2; + { + try { + result = (bool)(arg1)->RelayoutDependentOnChildren(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) { + bool jresult ; + Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; + bool result; + + arg1 = (Dali::CustomActorImpl *)jarg1; + { + try { + result = (bool)(arg1)->RelayoutDependentOnChildren(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) { + Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; + Dali::Dimension::Type arg2 ; + + arg1 = (Dali::CustomActorImpl *)jarg1; + arg2 = (Dali::Dimension::Type)jarg2; + { + try { + (arg1)->OnCalculateRelayoutSize(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) { + Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; + float arg2 ; + Dali::Dimension::Type arg3 ; + + arg1 = (Dali::CustomActorImpl *)jarg1; + arg2 = (float)jarg2; + arg3 = (Dali::Dimension::Type)jarg3; + { + try { + (arg1)->OnLayoutNegotiated(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) { + bool jresult ; + Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; + bool result; + + arg1 = (Dali::CustomActorImpl *)jarg1; + { + try { + result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() { + void * jresult ; + Dali::CustomActor *result = 0 ; + + { + try { + result = (Dali::CustomActor *)new Dali::CustomActor(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::CustomActor 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::CustomActor::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::CustomActor((const Dali::CustomActor &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) { + Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ; + + arg1 = (Dali::CustomActor *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) { + void * jresult ; + Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ; + Dali::CustomActorImpl *result = 0 ; + + arg1 = (Dali::CustomActor *)jarg1; + { + try { + result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) { + void * jresult ; + Dali::CustomActorImpl *arg1 = 0 ; + Dali::CustomActor *result = 0 ; + + arg1 = (Dali::CustomActorImpl *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0); + return 0; + } + { + try { + result = (Dali::CustomActor *)new Dali::CustomActor(*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) { + void * jresult ; + Dali::CustomActor *arg1 = 0 ; + Dali::CustomActor *result = 0 ; + + arg1 = (Dali::CustomActor *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0); + return 0; + } + { + try { + result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ; + Dali::CustomActor *arg2 = 0 ; + Dali::CustomActor *result = 0 ; + + arg1 = (Dali::CustomActor *)jarg1; + arg2 = (Dali::CustomActor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0); + return 0; + } + { + try { + result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() { + int jresult ; + int result; + + result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() { + int jresult ; + int result; + + result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() { + int jresult ; + int result; + + result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() { + int jresult ; + int result; + + result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() { + int jresult ; + int result; + + result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() { + int jresult ; + int result; + + result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() { + int jresult ; + int result; + + result = (int)Dali::PanGestureDetector::Property::PANNING; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() { + void * jresult ; + Dali::PanGestureDetector::Property *result = 0 ; + + { + try { + result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) { + Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ; + + arg1 = (Dali::PanGestureDetector::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() { + void * jresult ; + Dali::Radian *result = 0 ; + + result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() { + void * jresult ; + Dali::Radian *result = 0 ; + + result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() { + void * jresult ; + Dali::Radian *result = 0 ; + + result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() { + void * jresult ; + Dali::Radian *result = 0 ; + + result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() { + void * jresult ; + Dali::Radian *result = 0 ; + + result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() { + void * jresult ; + Dali::Radian *result = 0 ; + + result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() { + void * jresult ; + Dali::Radian *result = 0 ; + + result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() { + void * jresult ; + Dali::PanGestureDetector *result = 0 ; + + { + try { + result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() { + void * jresult ; + Dali::PanGestureDetector result; + + { + try { + result = Dali::PanGestureDetector::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::PanGestureDetector 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::PanGestureDetector::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) { + Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; + + arg1 = (Dali::PanGestureDetector *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) { + void * jresult ; + Dali::PanGestureDetector *arg1 = 0 ; + Dali::PanGestureDetector *result = 0 ; + + arg1 = (Dali::PanGestureDetector *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0); + return 0; + } + { + try { + result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; + Dali::PanGestureDetector *arg2 = 0 ; + Dali::PanGestureDetector *result = 0 ; + + arg1 = (Dali::PanGestureDetector *)jarg1; + arg2 = (Dali::PanGestureDetector *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0); + return 0; + } + { + try { + result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) { + Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::PanGestureDetector *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + (arg1)->SetMinimumTouchesRequired(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) { + Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::PanGestureDetector *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + (arg1)->SetMaximumTouchesRequired(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumMotionEventAge(void * jarg1, unsigned int jarg2) { + Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; + uint32_t arg2 ; + + arg1 = (Dali::PanGestureDetector *)jarg1; + arg2 = (uint32_t)jarg2; + { + try { + (arg1)->SetMaximumMotionEventAge(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) { + unsigned int jresult ; + Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; + unsigned int result; + + arg1 = (Dali::PanGestureDetector *)jarg1; + { + try { + result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) { + unsigned int jresult ; + Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; + unsigned int result; + + arg1 = (Dali::PanGestureDetector *)jarg1; + { + try { + result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumMotionEventAge(void * jarg1) { + unsigned int jresult ; + Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; + uint32_t result; + + arg1 = (Dali::PanGestureDetector *)jarg1; + { + try { + result = (uint32_t)((Dali::PanGestureDetector const *)arg1)->GetMaximumMotionEventAge(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { + Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; + Dali::Radian arg2 ; + Dali::Radian arg3 ; + Dali::Radian *argp2 ; + Dali::Radian *argp3 ; + + arg1 = (Dali::PanGestureDetector *)jarg1; + argp2 = (Dali::Radian *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Radian *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return ; + } + arg3 = *argp3; + { + try { + (arg1)->AddAngle(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) { + Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; + Dali::Radian arg2 ; + Dali::Radian *argp2 ; + + arg1 = (Dali::PanGestureDetector *)jarg1; + argp2 = (Dali::Radian *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->AddAngle(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { + Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; + Dali::Radian arg2 ; + Dali::Radian arg3 ; + Dali::Radian *argp2 ; + Dali::Radian *argp3 ; + + arg1 = (Dali::PanGestureDetector *)jarg1; + argp2 = (Dali::Radian *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Radian *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return ; + } + arg3 = *argp3; + { + try { + (arg1)->AddDirection(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) { + Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; + Dali::Radian arg2 ; + Dali::Radian *argp2 ; + + arg1 = (Dali::PanGestureDetector *)jarg1; + argp2 = (Dali::Radian *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->AddDirection(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) { + unsigned long jresult ; + Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; + size_t result; + + arg1 = (Dali::PanGestureDetector *)jarg1; + { + try { + result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; + size_t arg2 ; + Dali::PanGestureDetector::AngleThresholdPair result; + + arg1 = (Dali::PanGestureDetector *)jarg1; + arg2 = (size_t)jarg2; + { + try { + result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) { + Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; + + arg1 = (Dali::PanGestureDetector *)jarg1; + { + try { + (arg1)->ClearAngles(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) { + Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; + Dali::Radian arg2 ; + Dali::Radian *argp2 ; + + arg1 = (Dali::PanGestureDetector *)jarg1; + argp2 = (Dali::Radian *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->RemoveAngle(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) { + Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; + Dali::Radian arg2 ; + Dali::Radian *argp2 ; + + arg1 = (Dali::PanGestureDetector *)jarg1; + argp2 = (Dali::Radian *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->RemoveDirection(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) { + void * jresult ; + Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; + Dali::PanGestureDetector::DetectedSignalType *result = 0 ; + + arg1 = (Dali::PanGestureDetector *)jarg1; + { + try { + result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) { + Dali::PanGesture *arg1 = 0 ; + + arg1 = (Dali::PanGesture *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0); + return ; + } + { + try { + Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() { + void * jresult ; + Dali::PanGesture *result = 0 ; + + { + try { + result = (Dali::PanGesture *)new Dali::PanGesture(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_New(int jarg1) { + void * jresult ; + Dali::GestureState arg1 ; + Dali::PanGesture result; + + arg1 = (Dali::GestureState)jarg1; + { + try { + result = DevelPanGesture::New(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PanGesture((const Dali::PanGesture &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) { + void * jresult ; + Dali::PanGesture *arg1 = 0 ; + Dali::PanGesture *result = 0 ; + + arg1 = (Dali::PanGesture *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0); + return 0; + } + { + try { + result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; + Dali::PanGesture *arg2 = 0 ; + Dali::PanGesture *result = 0 ; + + arg1 = (Dali::PanGesture *)jarg1; + arg2 = (Dali::PanGesture *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0); + return 0; + } + { + try { + result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) { + Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; + + arg1 = (Dali::PanGesture *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) { + void * jresult ; + Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::PanGesture *)jarg1; + { + try { + result = ((Dali::PanGesture const *)arg1)->GetVelocity(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) { + void * jresult ; + Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::PanGesture *)jarg1; + { + try { + result = ((Dali::PanGesture const *)arg1)->GetDisplacement(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) { + void * jresult ; + Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::PanGesture *)jarg1; + { + try { + result = ((Dali::PanGesture const *)arg1)->GetPosition(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) { + void * jresult ; + Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::PanGesture *)jarg1; + { + try { + result = ((Dali::PanGesture const *)arg1)->GetScreenVelocity(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) { + void * jresult ; + Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::PanGesture *)jarg1; + { + try { + result = ((Dali::PanGesture const *)arg1)->GetScreenDisplacement(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) { + void * jresult ; + Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::PanGesture *)jarg1; + { + try { + result = ((Dali::PanGesture const *)arg1)->GetScreenPosition(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) { + unsigned int jresult ; + Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; + unsigned int result; + + arg1 = (Dali::PanGesture *)jarg1; + result = (unsigned int) ((arg1)->GetNumberOfTouches()); + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) { + float jresult ; + Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; + float result; + + arg1 = (Dali::PanGesture *)jarg1; + { + try { + result = (float)((Dali::PanGesture const *)arg1)->GetSpeed(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) { + float jresult ; + Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; + float result; + + arg1 = (Dali::PanGesture *)jarg1; + { + try { + result = (float)((Dali::PanGesture const *)arg1)->GetDistance(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) { + float jresult ; + Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; + float result; + + arg1 = (Dali::PanGesture *)jarg1; + { + try { + result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) { + float jresult ; + Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; + float result; + + arg1 = (Dali::PanGesture *)jarg1; + { + try { + result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() { + void * jresult ; + Dali::PinchGestureDetector *result = 0 ; + + { + try { + result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() { + void * jresult ; + Dali::PinchGestureDetector result; + + { + try { + result = Dali::PinchGestureDetector::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::PinchGestureDetector 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::PinchGestureDetector::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) { + Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ; + + arg1 = (Dali::PinchGestureDetector *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) { + void * jresult ; + Dali::PinchGestureDetector *arg1 = 0 ; + Dali::PinchGestureDetector *result = 0 ; + + arg1 = (Dali::PinchGestureDetector *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0); + return 0; + } + { + try { + result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ; + Dali::PinchGestureDetector *arg2 = 0 ; + Dali::PinchGestureDetector *result = 0 ; + + arg1 = (Dali::PinchGestureDetector *)jarg1; + arg2 = (Dali::PinchGestureDetector *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0); + return 0; + } + { + try { + result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) { + void * jresult ; + Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ; + Dali::PinchGestureDetector::DetectedSignalType *result = 0 ; + + arg1 = (Dali::PinchGestureDetector *)jarg1; + { + try { + result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0() { + void * jresult ; + Dali::PinchGesture *result = 0 ; + + { + try { + result = (Dali::PinchGesture *)new Dali::PinchGesture(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_New(int jarg1) { + void * jresult ; + Dali::GestureState arg1 ; + Dali::PinchGesture result; + + arg1 = (Dali::GestureState)jarg1; + { + try { + result = DevelPinchGesture::New(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PinchGesture((const Dali::PinchGesture &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) { + void * jresult ; + Dali::PinchGesture *arg1 = 0 ; + Dali::PinchGesture *result = 0 ; + + arg1 = (Dali::PinchGesture *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0); + return 0; + } + { + try { + result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ; + Dali::PinchGesture *arg2 = 0 ; + Dali::PinchGesture *result = 0 ; + + arg1 = (Dali::PinchGesture *)jarg1; + arg2 = (Dali::PinchGesture *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0); + return 0; + } + { + try { + result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) { + Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ; + + arg1 = (Dali::PinchGesture *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) { + float jresult ; + Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ; + float result; + + arg1 = (Dali::PinchGesture *)jarg1; + result = (float) ((arg1)->GetScale()); + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) { + float jresult ; + Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ; + float result; + + arg1 = (Dali::PinchGesture *)jarg1; + result = (float) ((arg1)->GetSpeed()); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) { + void * jresult ; + Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::PinchGesture *)jarg1; + { + try { + result = ((Dali::PinchGesture const *)arg1)->GetScreenCenterPoint(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) { + void * jresult ; + Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::PinchGesture *)jarg1; + { + try { + result = ((Dali::PinchGesture const *)arg1)->GetLocalCenterPoint(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() { + void * jresult ; + Dali::TapGestureDetector *result = 0 ; + + { + try { + result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() { + void * jresult ; + Dali::TapGestureDetector result; + + { + try { + result = Dali::TapGestureDetector::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) { + void * jresult ; + unsigned int arg1 ; + Dali::TapGestureDetector result; + + arg1 = (unsigned int)jarg1; + { + try { + result = Dali::TapGestureDetector::New(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::TapGestureDetector 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::TapGestureDetector::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) { + Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ; + + arg1 = (Dali::TapGestureDetector *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) { + void * jresult ; + Dali::TapGestureDetector *arg1 = 0 ; + Dali::TapGestureDetector *result = 0 ; + + arg1 = (Dali::TapGestureDetector *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0); + return 0; + } + { + try { + result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ; + Dali::TapGestureDetector *arg2 = 0 ; + Dali::TapGestureDetector *result = 0 ; + + arg1 = (Dali::TapGestureDetector *)jarg1; + arg2 = (Dali::TapGestureDetector *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0); + return 0; + } + { + try { + result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) { + Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::TapGestureDetector *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + (arg1)->SetMinimumTapsRequired(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) { + Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::TapGestureDetector *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + (arg1)->SetMaximumTapsRequired(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) { + unsigned int jresult ; + Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ; + unsigned int result; + + arg1 = (Dali::TapGestureDetector *)jarg1; + { + try { + result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) { + unsigned int jresult ; + Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ; + unsigned int result; + + arg1 = (Dali::TapGestureDetector *)jarg1; + { + try { + result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_ReceiveAllTapEvents(void * tapGestureDetector, bool isReceive) { + Dali::TapGestureDetector *detector = (Dali::TapGestureDetector *) 0 ; + + detector = (Dali::TapGestureDetector *)tapGestureDetector; + if (!detector) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0); + return; + } + { + try { + (detector)->ReceiveAllTapEvents(isReceive); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) { + void * jresult ; + Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ; + Dali::TapGestureDetector::DetectedSignalType *result = 0 ; + + arg1 = (Dali::TapGestureDetector *)jarg1; + { + try { + result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() { + void * jresult ; + Dali::TapGesture *result = 0 ; + + { + try { + result = (Dali::TapGesture *)new Dali::TapGesture(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_New(int jarg1) { + void * jresult ; + Dali::GestureState arg1 ; + Dali::TapGesture result; + + arg1 = (Dali::GestureState)jarg1; + { + try { + result = DevelTapGesture::New(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::TapGesture((const Dali::TapGesture &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) { + void * jresult ; + Dali::TapGesture *arg1 = 0 ; + Dali::TapGesture *result = 0 ; + + arg1 = (Dali::TapGesture *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0); + return 0; + } + { + try { + result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ; + Dali::TapGesture *arg2 = 0 ; + Dali::TapGesture *result = 0 ; + + arg1 = (Dali::TapGesture *)jarg1; + arg2 = (Dali::TapGesture *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0); + return 0; + } + { + try { + result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) { + Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ; + + arg1 = (Dali::TapGesture *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) { + unsigned int jresult ; + Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ; + unsigned int result; + + arg1 = (Dali::TapGesture *)jarg1; + result = (unsigned int) ((arg1)->GetNumberOfTaps()); + jresult = result; + return jresult; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) { + unsigned int jresult ; + Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ; + unsigned int result; + + arg1 = (Dali::TapGesture *)jarg1; + result = (unsigned int) ((arg1)->GetNumberOfTouches()); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) { + void * jresult ; + Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::TapGesture *)jarg1; + { + try { + result = ((Dali::TapGesture const *)arg1)->GetScreenPoint(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) { + void * jresult ; + Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::TapGesture *)jarg1; + { + try { + result = ((Dali::TapGesture const *)arg1)->GetLocalPoint(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() { + void * jresult ; + Dali::AlphaFunction *result = 0 ; + + { + try { + result = (Dali::AlphaFunction *)new Dali::AlphaFunction(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) { + void * jresult ; + Dali::AlphaFunction::BuiltinFunction arg1 ; + Dali::AlphaFunction *result = 0 ; + + arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1; + { + try { + result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) { + void * jresult ; + Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ; + Dali::AlphaFunction *result = 0 ; + + arg1 = (Dali::AlphaFunctionPrototype)jarg1; + { + try { + result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector2 *arg1 = 0 ; + Dali::Vector2 *arg2 = 0 ; + Dali::AlphaFunction *result = 0 ; + + arg1 = (Dali::Vector2 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) { + void * jresult ; + Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ; + Dali::Vector4 result; + + arg1 = (Dali::AlphaFunction *)jarg1; + { + try { + result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) { + void * jresult ; + Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ; + Dali::AlphaFunctionPrototype result; + + arg1 = (Dali::AlphaFunction *)jarg1; + { + try { + result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) { + int jresult ; + Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ; + Dali::AlphaFunction::BuiltinFunction result; + + arg1 = (Dali::AlphaFunction *)jarg1; + { + try { + result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) { + int jresult ; + Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ; + Dali::AlphaFunction::Mode result; + + arg1 = (Dali::AlphaFunction *)jarg1; + { + try { + result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) { + Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ; + + arg1 = (Dali::AlphaFunction *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() { + void * jresult ; + Dali::KeyFrames result; + + { + try { + result = Dali::KeyFrames::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::KeyFrames 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::KeyFrames::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() { + void * jresult ; + Dali::KeyFrames *result = 0 ; + + { + try { + result = (Dali::KeyFrames *)new Dali::KeyFrames(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) { + Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ; + + arg1 = (Dali::KeyFrames *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) { + void * jresult ; + Dali::KeyFrames *arg1 = 0 ; + Dali::KeyFrames *result = 0 ; + + arg1 = (Dali::KeyFrames *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0); + return 0; + } + { + try { + result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ; + Dali::KeyFrames *arg2 = 0 ; + Dali::KeyFrames *result = 0 ; + + arg1 = (Dali::KeyFrames *)jarg1; + arg2 = (Dali::KeyFrames *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0); + return 0; + } + { + try { + result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) { + int jresult ; + Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ; + Dali::Property::Type result; + + arg1 = (Dali::KeyFrames *)jarg1; + { + try { + result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) { + Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ; + float arg2 ; + Dali::Property::Value arg3 ; + Dali::Property::Value *argp3 ; + + arg1 = (Dali::KeyFrames *)jarg1; + arg2 = (float)jarg2; + argp3 = (Dali::Property::Value *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); + return ; + } + arg3 = *argp3; + { + try { + (arg1)->Add(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) { + Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ; + float arg2 ; + Dali::Property::Value arg3 ; + Dali::AlphaFunction arg4 ; + Dali::Property::Value *argp3 ; + Dali::AlphaFunction *argp4 ; + + arg1 = (Dali::KeyFrames *)jarg1; + arg2 = (float)jarg2; + argp3 = (Dali::Property::Value *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); + return ; + } + arg3 = *argp3; + argp4 = (Dali::AlphaFunction *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); + return ; + } + arg4 = *argp4; + { + try { + (arg1)->Add(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrameCount(void* keyFrames) +{ + unsigned int jresult; + { + try { + jresult = Dali::DevelKeyFrames::GetKeyFrameCount(*((Dali::KeyFrames*)keyFrames)); + } CALL_CATCH_EXCEPTION(0); + } + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrame(void* keyFrames, unsigned int index, float* time, void* value) +{ + if (!value) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); + return ; + } + try { + Dali::DevelKeyFrames::GetKeyFrame(*((Dali::KeyFrames*)keyFrames), (size_t)index, *time, *((Property::Value*)value)); + } CALL_CATCH_EXCEPTION(); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_SetKeyFrameValue(void* keyFrames, unsigned int index, void* value) +{ + if (!value) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); + return ; + } + try { + Dali::DevelKeyFrames::SetKeyFrameValue(*((Dali::KeyFrames*)keyFrames), (size_t)index, *((const Property::Value*)value)); + } CALL_CATCH_EXCEPTION(); +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() { + int jresult ; + int result; + + result = (int)Dali::Path::Property::POINTS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() { + int jresult ; + int result; + + result = (int)Dali::Path::Property::CONTROL_POINTS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() { + void * jresult ; + Dali::Path::Property *result = 0 ; + + { + try { + result = (Dali::Path::Property *)new Dali::Path::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) { + Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ; + + arg1 = (Dali::Path::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() { + void * jresult ; + Dali::Path result; + + { + try { + result = Dali::Path::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Path((const Dali::Path &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Path 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::Path::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Path((const Dali::Path &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() { + void * jresult ; + Dali::Path *result = 0 ; + + { + try { + result = (Dali::Path *)new Dali::Path(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) { + Dali::Path *arg1 = (Dali::Path *) 0 ; + + arg1 = (Dali::Path *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Path *arg1 = 0 ; + Dali::Path *result = 0 ; + + arg1 = (Dali::Path *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Path *arg1 = (Dali::Path *) 0 ; + Dali::Path *arg2 = 0 ; + Dali::Path *result = 0 ; + + arg1 = (Dali::Path *)jarg1; + arg2 = (Dali::Path *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) { + Dali::Path *arg1 = (Dali::Path *) 0 ; + Dali::Vector3 *arg2 = 0 ; + + arg1 = (Dali::Path *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + { + try { + (arg1)->AddPoint((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) { + Dali::Path *arg1 = (Dali::Path *) 0 ; + Dali::Vector3 *arg2 = 0 ; + + arg1 = (Dali::Path *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + { + try { + (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) { + Dali::Path *arg1 = (Dali::Path *) 0 ; + float arg2 ; + + arg1 = (Dali::Path *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->GenerateControlPoints(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) { + Dali::Path *arg1 = (Dali::Path *) 0 ; + float arg2 ; + Dali::Vector3 *arg3 = 0 ; + Dali::Vector3 *arg4 = 0 ; + + arg1 = (Dali::Path *)jarg1; + arg2 = (float)jarg2; + arg3 = (Dali::Vector3 *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); + return ; + } + arg4 = (Dali::Vector3 *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); + return ; + } + { + try { + ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::Path *arg1 = (Dali::Path *) 0 ; + size_t arg2 ; + Dali::Vector3 *result = 0 ; + + arg1 = (Dali::Path *)jarg1; + arg2 = (size_t)jarg2; + { + try { + result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::Path *arg1 = (Dali::Path *) 0 ; + size_t arg2 ; + Dali::Vector3 *result = 0 ; + + arg1 = (Dali::Path *)jarg1; + arg2 = (size_t)jarg2; + { + try { + result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) { + unsigned long jresult ; + Dali::Path *arg1 = (Dali::Path *) 0 ; + size_t result; + + arg1 = (Dali::Path *)jarg1; + { + try { + result = ((Dali::Path const *)arg1)->GetPointCount(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) { + void * jresult ; + float arg1 ; + Dali::TimePeriod *result = 0 ; + + arg1 = (float)jarg1; + { + try { + result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) { + void * jresult ; + float arg1 ; + float arg2 ; + Dali::TimePeriod *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + { + try { + result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) { + Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ; + + arg1 = (Dali::TimePeriod *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) { + Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ; + float arg2 ; + + arg1 = (Dali::TimePeriod *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->delaySeconds = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) { + float jresult ; + Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ; + float result; + + arg1 = (Dali::TimePeriod *)jarg1; + result = (float) ((arg1)->delaySeconds); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) { + Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ; + float arg2 ; + + arg1 = (Dali::TimePeriod *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->durationSeconds = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) { + float jresult ; + Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ; + float result; + + arg1 = (Dali::TimePeriod *)jarg1; + result = (float) ((arg1)->durationSeconds); + jresult = result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() { + int jresult ; + int result; + + result = (int)Dali::LinearConstrainer::Property::VALUE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() { + int jresult ; + int result; + + result = (int)Dali::LinearConstrainer::Property::PROGRESS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() { + void * jresult ; + Dali::LinearConstrainer::Property *result = 0 ; + + { + try { + result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) { + Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ; + + arg1 = (Dali::LinearConstrainer::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() { + void * jresult ; + Dali::LinearConstrainer result; + + { + try { + result = Dali::LinearConstrainer::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::LinearConstrainer 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::LinearConstrainer::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() { + void * jresult ; + Dali::LinearConstrainer *result = 0 ; + + { + try { + result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) { + Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ; + + arg1 = (Dali::LinearConstrainer *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) { + void * jresult ; + Dali::LinearConstrainer *arg1 = 0 ; + Dali::LinearConstrainer *result = 0 ; + + arg1 = (Dali::LinearConstrainer *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0); + return 0; + } + { + try { + result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ; + Dali::LinearConstrainer *arg2 = 0 ; + Dali::LinearConstrainer *result = 0 ; + + arg1 = (Dali::LinearConstrainer *)jarg1; + arg2 = (Dali::LinearConstrainer *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0); + return 0; + } + { + try { + result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) { + Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + SwigValueWrapper< Dali::Property > arg3 ; + Dali::Vector2 *arg4 = 0 ; + Dali::Vector2 *arg5 = 0 ; + Dali::Property *argp2 ; + Dali::Property *argp3 ; + + arg1 = (Dali::LinearConstrainer *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Property *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg3 = *argp3; + arg4 = (Dali::Vector2 *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + arg5 = (Dali::Vector2 *)jarg5; + if (!arg5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + { + try { + (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { + Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + SwigValueWrapper< Dali::Property > arg3 ; + Dali::Vector2 *arg4 = 0 ; + Dali::Property *argp2 ; + Dali::Property *argp3 ; + + arg1 = (Dali::LinearConstrainer *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Property *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg3 = *argp3; + arg4 = (Dali::Vector2 *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + { + try { + (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) { + Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ; + Dali::Handle *arg2 = 0 ; + + arg1 = (Dali::LinearConstrainer *)jarg1; + arg2 = (Dali::Handle *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); + return ; + } + { + try { + (arg1)->Remove(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() { + int jresult ; + int result; + + result = (int)Dali::PathConstrainer::Property::FORWARD; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() { + int jresult ; + int result; + + result = (int)Dali::PathConstrainer::Property::POINTS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() { + int jresult ; + int result; + + result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() { + void * jresult ; + Dali::PathConstrainer::Property *result = 0 ; + + { + try { + result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) { + Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ; + + arg1 = (Dali::PathConstrainer::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() { + void * jresult ; + Dali::PathConstrainer result; + + { + try { + result = Dali::PathConstrainer::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::PathConstrainer 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::PathConstrainer::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() { + void * jresult ; + Dali::PathConstrainer *result = 0 ; + + { + try { + result = (Dali::PathConstrainer *)new Dali::PathConstrainer(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) { + Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ; + + arg1 = (Dali::PathConstrainer *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) { + void * jresult ; + Dali::PathConstrainer *arg1 = 0 ; + Dali::PathConstrainer *result = 0 ; + + arg1 = (Dali::PathConstrainer *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0); + return 0; + } + { + try { + result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ; + Dali::PathConstrainer *arg2 = 0 ; + Dali::PathConstrainer *result = 0 ; + + arg1 = (Dali::PathConstrainer *)jarg1; + arg2 = (Dali::PathConstrainer *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0); + return 0; + } + { + try { + result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) { + Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + SwigValueWrapper< Dali::Property > arg3 ; + Dali::Vector2 *arg4 = 0 ; + Dali::Vector2 *arg5 = 0 ; + Dali::Property *argp2 ; + Dali::Property *argp3 ; + + arg1 = (Dali::PathConstrainer *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Property *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg3 = *argp3; + arg4 = (Dali::Vector2 *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + arg5 = (Dali::Vector2 *)jarg5; + if (!arg5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + { + try { + (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { + Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + SwigValueWrapper< Dali::Property > arg3 ; + Dali::Vector2 *arg4 = 0 ; + Dali::Property *argp2 ; + Dali::Property *argp3 ; + + arg1 = (Dali::PathConstrainer *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Property *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg3 = *argp3; + arg4 = (Dali::Vector2 *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + { + try { + (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) { + Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ; + Dali::Handle *arg2 = 0 ; + + arg1 = (Dali::PathConstrainer *)jarg1; + arg2 = (Dali::Handle *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); + return ; + } + { + try { + (arg1)->Remove(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() { + int jresult ; + Dali::FittingMode::Type result; + + result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() { + int jresult ; + Dali::SamplingMode::Type result; + + result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) { + bool jresult ; + Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ; + bool result; + + arg1 = (Dali::NativeImageInterface *)jarg1; + { + try { + result = (bool)(arg1)->CreateResource(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) { + Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ; + + arg1 = (Dali::NativeImageInterface *)jarg1; + { + try { + (arg1)->DestroyResource(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) { + unsigned int jresult ; + Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ; + unsigned int result; + + arg1 = (Dali::NativeImageInterface *)jarg1; + { + try { + result = (unsigned int)(arg1)->TargetTexture(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) { + Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ; + + arg1 = (Dali::NativeImageInterface *)jarg1; + { + try { + (arg1)->PrepareTexture(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) { + unsigned int jresult ; + Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ; + unsigned int result; + + arg1 = (Dali::NativeImageInterface *)jarg1; + { + try { + result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) { + unsigned int jresult ; + Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ; + unsigned int result; + + arg1 = (Dali::NativeImageInterface *)jarg1; + { + try { + result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) { + bool jresult ; + Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ; + bool result; + + arg1 = (Dali::NativeImageInterface *)jarg1; + { + try { + result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() { + int jresult ; + int result; + + result = (int)Dali::CameraActor::Property::TYPE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() { + int jresult ; + int result; + + result = (int)Dali::CameraActor::Property::PROJECTION_MODE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() { + int jresult ; + int result; + + result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() { + int jresult ; + int result; + + result = (int)Dali::CameraActor::Property::ASPECT_RATIO; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() { + int jresult ; + int result; + + result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() { + int jresult ; + int result; + + result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() { + int jresult ; + int result; + + result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() { + int jresult ; + int result; + + result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() { + int jresult ; + int result; + + result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() { + int jresult ; + int result; + + result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() { + int jresult ; + int result; + + result = (int)Dali::CameraActor::Property::TARGET_POSITION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() { + int jresult ; + int result; + + result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() { + int jresult ; + int result; + + result = (int)Dali::CameraActor::Property::VIEW_MATRIX; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() { + int jresult ; + int result; + + result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ORTHOGRAPHIC_SIZE_get() { + int jresult ; + int result; + + result = (int)Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_DIRECTION_get() { + int jresult ; + int result; + + result = (int)Dali::DevelCameraActor::Property::PROJECTION_DIRECTION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() { + void * jresult ; + Dali::CameraActor::Property *result = 0 ; + + { + try { + result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) { + Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ; + + arg1 = (Dali::CameraActor::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() { + void * jresult ; + Dali::CameraActor *result = 0 ; + + { + try { + result = (Dali::CameraActor *)new Dali::CameraActor(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() { + void * jresult ; + Dali::CameraActor result; + + { + try { + result = Dali::CameraActor::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::CameraActor((const Dali::CameraActor &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Size *arg1 = 0 ; + Dali::CameraActor result; + + arg1 = (Dali::Size *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0); + return 0; + } + { + try { + result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::CameraActor((const Dali::CameraActor &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New3DCamera() { + void * jresult ; + Dali::CameraActor result; + + { + try { + result = Dali::CameraActor::New3DCamera(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::CameraActor((const Dali::CameraActor &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::CameraActor 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::CameraActor::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::CameraActor((const Dali::CameraActor &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) { + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + + arg1 = (Dali::CameraActor *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) { + void * jresult ; + Dali::CameraActor *arg1 = 0 ; + Dali::CameraActor *result = 0 ; + + arg1 = (Dali::CameraActor *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0); + return 0; + } + { + try { + result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + Dali::CameraActor *arg2 = 0 ; + Dali::CameraActor *result = 0 ; + + arg1 = (Dali::CameraActor *)jarg1; + arg2 = (Dali::CameraActor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0); + return 0; + } + { + try { + result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) { + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + Dali::Camera::Type arg2 ; + + arg1 = (Dali::CameraActor *)jarg1; + arg2 = (Dali::Camera::Type)jarg2; + { + try { + (arg1)->SetType(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) { + int jresult ; + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + Dali::Camera::Type result; + + arg1 = (Dali::CameraActor *)jarg1; + { + try { + result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) { + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + Dali::Camera::ProjectionMode arg2 ; + + arg1 = (Dali::CameraActor *)jarg1; + arg2 = (Dali::Camera::ProjectionMode)jarg2; + { + try { + (arg1)->SetProjectionMode(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) { + int jresult ; + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + Dali::Camera::ProjectionMode result; + + arg1 = (Dali::CameraActor *)jarg1; + { + try { + result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) { + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + float arg2 ; + + arg1 = (Dali::CameraActor *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetFieldOfView(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) { + float jresult ; + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + float result; + + arg1 = (Dali::CameraActor *)jarg1; + { + try { + result = (float)(arg1)->GetFieldOfView(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) { + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + float arg2 ; + + arg1 = (Dali::CameraActor *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetAspectRatio(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) { + float jresult ; + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + float result; + + arg1 = (Dali::CameraActor *)jarg1; + { + try { + result = (float)(arg1)->GetAspectRatio(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) { + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + float arg2 ; + + arg1 = (Dali::CameraActor *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetNearClippingPlane(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) { + float jresult ; + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + float result; + + arg1 = (Dali::CameraActor *)jarg1; + { + try { + result = (float)(arg1)->GetNearClippingPlane(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) { + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + float arg2 ; + + arg1 = (Dali::CameraActor *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetFarClippingPlane(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) { + float jresult ; + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + float result; + + arg1 = (Dali::CameraActor *)jarg1; + { + try { + result = (float)(arg1)->GetFarClippingPlane(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) { + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + Dali::Vector3 *arg2 = 0 ; + + arg1 = (Dali::CameraActor *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) { + void * jresult ; + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + Dali::Vector3 result; + + arg1 = (Dali::CameraActor *)jarg1; + { + try { + result = ((Dali::CameraActor const *)arg1)->GetTargetPosition(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, bool jarg2) { + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + bool arg2 ; + + arg1 = (Dali::CameraActor *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->SetInvertYAxis(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) { + bool jresult ; + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + bool result; + + arg1 = (Dali::CameraActor *)jarg1; + { + try { + result = (bool)(arg1)->GetInvertYAxis(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) { + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + Dali::Size *arg2 = 0 ; + + arg1 = (Dali::CameraActor *)jarg1; + arg2 = (Dali::Size *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0); + return ; + } + { + try { + (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) { + Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; + Dali::Size *arg2 = 0 ; + + arg1 = (Dali::CameraActor *)jarg1; + arg2 = (Dali::Size *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0); + return ; + } + { + try { + (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() { + void * jresult ; + std::pair< std::string,Dali::Property::Value > *result = 0 ; + + { + try { + result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) { + void * jresult ; + std::string arg1 ; + Dali::Property::Value arg2 ; + Dali::Property::Value *argp2 ; + std::pair< std::string,Dali::Property::Value > *result = 0 ; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + (&arg1)->assign(jarg1); + argp2 = (Dali::Property::Value *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) { + void * jresult ; + std::pair< std::string,Dali::Property::Value > *arg1 = 0 ; + std::pair< std::string,Dali::Property::Value > *result = 0 ; + + arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0); + return 0; + } + { + try { + result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >((std::pair< std::string,Dali::Property::Value > const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) { + std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + if (arg1) (arg1)->first = *arg2; + + //argout typemap for const std::string& + +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) { + char * jresult ; + std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ; + std::string *result = 0 ; + + arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1; + result = (std::string *) & ((arg1)->first); + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) { + std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ; + Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ; + + arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1; + arg2 = (Dali::Property::Value *)jarg2; + if (arg1) (arg1)->second = *arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) { + void * jresult ; + std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ; + Dali::Property::Value *result = 0 ; + + arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1; + result = (Dali::Property::Value *)& ((arg1)->second); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) { + std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ; + + arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) { + std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; + + arg1 = (std::vector< Dali::TouchPoint > *)jarg1; + { + try { + (arg1)->clear(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) { + std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; + Dali::TouchPoint *arg2 = 0 ; + + arg1 = (std::vector< Dali::TouchPoint > *)jarg1; + arg2 = (Dali::TouchPoint *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0); + return ; + } + { + try { + (arg1)->push_back((Dali::TouchPoint const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) { + unsigned long jresult ; + std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; + std::vector< Dali::TouchPoint >::size_type result; + + arg1 = (std::vector< Dali::TouchPoint > *)jarg1; + { + try { + result = ((std::vector< Dali::TouchPoint > const *)arg1)->size(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) { + unsigned long jresult ; + std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; + std::vector< Dali::TouchPoint >::size_type result; + + arg1 = (std::vector< Dali::TouchPoint > *)jarg1; + { + try { + result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) { + std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; + std::vector< Dali::TouchPoint >::size_type arg2 ; + + arg1 = (std::vector< Dali::TouchPoint > *)jarg1; + arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2; + { + try { + (arg1)->reserve(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() { + void * jresult ; + std::vector< Dali::TouchPoint > *result = 0 ; + + { + try { + result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) { + void * jresult ; + std::vector< Dali::TouchPoint > *arg1 = 0 ; + std::vector< Dali::TouchPoint > *result = 0 ; + + arg1 = (std::vector< Dali::TouchPoint > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0); + return 0; + } + { + try { + result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) { + void * jresult ; + int arg1 ; + std::vector< Dali::TouchPoint > *result = 0 ; + + arg1 = (int)jarg1; + { + try { + try { + result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) { + void * jresult ; + std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; + int arg2 ; + SwigValueWrapper< Dali::TouchPoint > result; + + arg1 = (std::vector< Dali::TouchPoint > *)jarg1; + arg2 = (int)jarg2; + { + try { + try { + result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) { + void * jresult ; + std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; + int arg2 ; + Dali::TouchPoint *result = 0 ; + + arg1 = (std::vector< Dali::TouchPoint > *)jarg1; + arg2 = (int)jarg2; + { + try { + try { + result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) { + std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; + int arg2 ; + Dali::TouchPoint *arg3 = 0 ; + + arg1 = (std::vector< Dali::TouchPoint > *)jarg1; + arg2 = (int)jarg2; + arg3 = (Dali::TouchPoint *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0); + return ; + } + { + try { + try { + std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) { + std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; + std::vector< Dali::TouchPoint > *arg2 = 0 ; + + arg1 = (std::vector< Dali::TouchPoint > *)jarg1; + arg2 = (std::vector< Dali::TouchPoint > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0); + return ; + } + { + try { + std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) { + void * jresult ; + std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; + int arg2 ; + int arg3 ; + std::vector< Dali::TouchPoint > *result = 0 ; + + arg1 = (std::vector< Dali::TouchPoint > *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + { + try { + try { + result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + catch(std::invalid_argument &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) { + std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; + int arg2 ; + Dali::TouchPoint *arg3 = 0 ; + + arg1 = (std::vector< Dali::TouchPoint > *)jarg1; + arg2 = (int)jarg2; + arg3 = (Dali::TouchPoint *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0); + return ; + } + { + try { + try { + std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) { + std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; + int arg2 ; + std::vector< Dali::TouchPoint > *arg3 = 0 ; + + arg1 = (std::vector< Dali::TouchPoint > *)jarg1; + arg2 = (int)jarg2; + arg3 = (std::vector< Dali::TouchPoint > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0); + return ; + } + { + try { + try { + std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) { + std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; + int arg2 ; + + arg1 = (std::vector< Dali::TouchPoint > *)jarg1; + arg2 = (int)jarg2; + { + try { + try { + std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) { + std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = (std::vector< Dali::TouchPoint > *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + { + try { + try { + std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + catch(std::invalid_argument &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) { + void * jresult ; + Dali::TouchPoint *arg1 = 0 ; + int arg2 ; + std::vector< Dali::TouchPoint > *result = 0 ; + + arg1 = (Dali::TouchPoint *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0); + return 0; + } + arg2 = (int)jarg2; + { + try { + try { + result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) { + std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; + + arg1 = (std::vector< Dali::TouchPoint > *)jarg1; + { + try { + std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) { + std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = (std::vector< Dali::TouchPoint > *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + { + try { + try { + std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + catch(std::invalid_argument &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) { + std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; + int arg2 ; + std::vector< Dali::TouchPoint > *arg3 = 0 ; + + arg1 = (std::vector< Dali::TouchPoint > *)jarg1; + arg2 = (int)jarg2; + arg3 = (std::vector< Dali::TouchPoint > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0); + return ; + } + { + try { + try { + std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) { + std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; + + arg1 = (std::vector< Dali::TouchPoint > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() { + void * jresult ; + Dali::Rect< int > *result = 0 ; + + { + try { + result = (Dali::Rect< int > *)new Dali::Rect< int >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) { + void * jresult ; + int arg1 ; + int arg2 ; + int arg3 ; + int arg4 ; + Dali::Rect< int > *result = 0 ; + + arg1 = (int)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + arg4 = (int)jarg4; + { + try { + result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) { + void * jresult ; + Dali::Rect< int > *arg1 = 0 ; + Dali::Rect< int > *result = 0 ; + + arg1 = (Dali::Rect< int > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + Dali::Rect< int > *arg2 = 0 ; + Dali::Rect< int > *result = 0 ; + + arg1 = (Dali::Rect< int > *)jarg1; + arg2 = (Dali::Rect< int > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) { + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int arg2 ; + int arg3 ; + int arg4 ; + int arg5 ; + + arg1 = (Dali::Rect< int > *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + arg4 = (int)jarg4; + arg5 = (int)jarg5; + { + try { + (arg1)->Set(arg2,arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) { + bool jresult ; + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + bool result; + + arg1 = (Dali::Rect< int > *)jarg1; + { + try { + result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) { + int jresult ; + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int result; + + arg1 = (Dali::Rect< int > *)jarg1; + { + try { + result = (int)((Dali::Rect< int > const *)arg1)->Left(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) { + int jresult ; + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int result; + + arg1 = (Dali::Rect< int > *)jarg1; + { + try { + result = (int)((Dali::Rect< int > const *)arg1)->Right(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) { + int jresult ; + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int result; + + arg1 = (Dali::Rect< int > *)jarg1; + { + try { + result = (int)((Dali::Rect< int > const *)arg1)->Top(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) { + int jresult ; + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int result; + + arg1 = (Dali::Rect< int > *)jarg1; + { + try { + result = (int)((Dali::Rect< int > const *)arg1)->Bottom(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) { + int jresult ; + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int result; + + arg1 = (Dali::Rect< int > *)jarg1; + { + try { + result = (int)((Dali::Rect< int > const *)arg1)->Area(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + Dali::Rect< int > *arg2 = 0 ; + bool result; + + arg1 = (Dali::Rect< int > *)jarg1; + arg2 = (Dali::Rect< int > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + Dali::Rect< int > *arg2 = 0 ; + bool result; + + arg1 = (Dali::Rect< int > *)jarg1; + arg2 = (Dali::Rect< int > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) { + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int arg2 ; + + arg1 = (Dali::Rect< int > *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->x = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) { + int jresult ; + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int result; + + arg1 = (Dali::Rect< int > *)jarg1; + result = (int) ((arg1)->x); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) { + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int arg2 ; + + arg1 = (Dali::Rect< int > *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->left = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) { + int jresult ; + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int result; + + arg1 = (Dali::Rect< int > *)jarg1; + result = (int) ((arg1)->left); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) { + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int arg2 ; + + arg1 = (Dali::Rect< int > *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->y = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) { + int jresult ; + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int result; + + arg1 = (Dali::Rect< int > *)jarg1; + result = (int) ((arg1)->y); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) { + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int arg2 ; + + arg1 = (Dali::Rect< int > *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->right = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) { + int jresult ; + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int result; + + arg1 = (Dali::Rect< int > *)jarg1; + result = (int) ((arg1)->right); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) { + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int arg2 ; + + arg1 = (Dali::Rect< int > *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->width = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) { + int jresult ; + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int result; + + arg1 = (Dali::Rect< int > *)jarg1; + result = (int) ((arg1)->width); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) { + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int arg2 ; + + arg1 = (Dali::Rect< int > *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->bottom = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) { + int jresult ; + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int result; + + arg1 = (Dali::Rect< int > *)jarg1; + result = (int) ((arg1)->bottom); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) { + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int arg2 ; + + arg1 = (Dali::Rect< int > *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->height = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) { + int jresult ; + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int result; + + arg1 = (Dali::Rect< int > *)jarg1; + result = (int) ((arg1)->height); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) { + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int arg2 ; + + arg1 = (Dali::Rect< int > *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->top = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) { + int jresult ; + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + int result; + + arg1 = (Dali::Rect< int > *)jarg1; + result = (int) ((arg1)->top); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) { + Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; + + arg1 = (Dali::Rect< int > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() { + void * jresult ; + Dali::Rect< float > *result = 0 ; + + { + try { + result = (Dali::Rect< float > *)new Dali::Rect< float >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) { + void * jresult ; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + Dali::Rect< float > *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg4; + arg4 = (float)jarg3; + { + try { + result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) { + void * jresult ; + Dali::Rect< float > *arg1 = 0 ; + Dali::Rect< float > *result = 0 ; + + arg1 = (Dali::Rect< float > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; + Dali::Rect< float > *arg2 = 0 ; + Dali::Rect< float > *result = 0 ; + + arg1 = (Dali::Rect< float > *)jarg1; + arg2 = (Dali::Rect< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) { + Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + arg1 = (Dali::Rect< float > *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg5; + arg5 = (float)jarg4; + { + try { + (arg1)->Set(arg2,arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) { + Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; + float arg2 ; + + arg1 = (Dali::Rect< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->left = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) { + float jresult ; + Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; + float result; + + arg1 = (Dali::Rect< float > *)jarg1; + result = (float) ((arg1)->left); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) { + Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; + float arg2 ; + + arg1 = (Dali::Rect< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->left = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) { + float jresult ; + Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; + float result; + + arg1 = (Dali::Rect< float > *)jarg1; + result = (float) ((arg1)->left); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) { + Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; + float arg2 ; + + arg1 = (Dali::Rect< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->right = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) { + float jresult ; + Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; + float result; + + arg1 = (Dali::Rect< float > *)jarg1; + result = (float) ((arg1)->right); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) { + Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; + float arg2 ; + + arg1 = (Dali::Rect< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->right = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) { + float jresult ; + Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; + float result; + + arg1 = (Dali::Rect< float > *)jarg1; + result = (float) ((arg1)->right); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) { + Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; + float arg2 ; + + arg1 = (Dali::Rect< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->bottom = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) { + float jresult ; + Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; + float result; + + arg1 = (Dali::Rect< float > *)jarg1; + result = (float) ((arg1)->bottom); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) { + Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; + float arg2 ; + + arg1 = (Dali::Rect< float > *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->top = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) { + float jresult ; + Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; + float result; + + arg1 = (Dali::Rect< float > *)jarg1; + result = (float) ((arg1)->top); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) { + Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; + + arg1 = (Dali::Rect< float > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() { + int jresult ; + int result; + + result = (int)Dali::Vector< int >::BaseType; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() { + void * jresult ; + Dali::Vector< int > *result = 0 ; + + { + try { + result = (Dali::Vector< int > *)new Dali::Vector< int >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) { + Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; + + arg1 = (Dali::Vector< int > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Vector< int > *arg1 = 0 ; + Dali::Vector< int > *result = 0 ; + + arg1 = (Dali::Vector< int > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; + Dali::Vector< int > *arg2 = 0 ; + Dali::Vector< int > *result = 0 ; + + arg1 = (Dali::Vector< int > *)jarg1; + arg2 = (Dali::Vector< int > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) { + void * jresult ; + Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; + Dali::Vector< int >::Iterator result; + + arg1 = (Dali::Vector< int > *)jarg1; + { + try { + result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) { + void * jresult ; + Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; + Dali::Vector< int >::Iterator result; + + arg1 = (Dali::Vector< int > *)jarg1; + { + try { + result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; + Dali::Vector< int >::SizeType arg2 ; + Dali::Vector< int >::ItemType *result = 0 ; + + arg1 = (Dali::Vector< int > *)jarg1; + arg2 = (Dali::Vector< int >::SizeType)jarg2; + { + try { + result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) { + Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; + Dali::Vector< int >::ItemType *arg2 = 0 ; + Dali::Vector< int >::ItemType temp2 ; + + arg1 = (Dali::Vector< int > *)jarg1; + temp2 = (Dali::Vector< int >::ItemType)jarg2; + arg2 = &temp2; + { + try { + (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) { + Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; + Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ; + Dali::Vector< int >::ItemType *arg3 = 0 ; + Dali::Vector< int >::ItemType temp3 ; + + arg1 = (Dali::Vector< int > *)jarg1; + arg2 = (Dali::Vector< int >::Iterator)jarg2; + temp3 = (Dali::Vector< int >::ItemType)jarg3; + arg3 = &temp3; + { + try { + (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { + Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; + Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ; + Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ; + Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ; + + arg1 = (Dali::Vector< int > *)jarg1; + arg2 = (Dali::Vector< int >::Iterator)jarg2; + arg3 = (Dali::Vector< int >::Iterator)jarg3; + arg4 = (Dali::Vector< int >::Iterator)jarg4; + { + try { + (arg1)->Insert(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) { + Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; + Dali::Vector< int >::SizeType arg2 ; + + arg1 = (Dali::Vector< int > *)jarg1; + arg2 = (Dali::Vector< int >::SizeType)jarg2; + { + try { + (arg1)->Reserve(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) { + Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; + Dali::Vector< int >::SizeType arg2 ; + + arg1 = (Dali::Vector< int > *)jarg1; + arg2 = (Dali::Vector< int >::SizeType)jarg2; + { + try { + (arg1)->Resize(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) { + Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; + Dali::Vector< int >::SizeType arg2 ; + Dali::Vector< int >::ItemType *arg3 = 0 ; + Dali::Vector< int >::ItemType temp3 ; + + arg1 = (Dali::Vector< int > *)jarg1; + arg2 = (Dali::Vector< int >::SizeType)jarg2; + temp3 = (Dali::Vector< int >::ItemType)jarg3; + arg3 = &temp3; + { + try { + (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; + Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ; + Dali::Vector< int >::Iterator result; + + arg1 = (Dali::Vector< int > *)jarg1; + arg2 = (Dali::Vector< int >::Iterator)jarg2; + { + try { + result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) { + void * jresult ; + Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; + Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ; + Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ; + Dali::Vector< int >::Iterator result; + + arg1 = (Dali::Vector< int > *)jarg1; + arg2 = (Dali::Vector< int >::Iterator)jarg2; + arg3 = (Dali::Vector< int >::Iterator)jarg3; + { + try { + result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) { + Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; + Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ; + + arg1 = (Dali::Vector< int > *)jarg1; + arg2 = (Dali::Vector< int >::Iterator)jarg2; + { + try { + (arg1)->Remove(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) { + Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; + Dali::Vector< int > *arg2 = 0 ; + + arg1 = (Dali::Vector< int > *)jarg1; + arg2 = (Dali::Vector< int > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0); + return ; + } + { + try { + (arg1)->Swap(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) { + Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; + + arg1 = (Dali::Vector< int > *)jarg1; + { + try { + (arg1)->Clear(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) { + Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; + + arg1 = (Dali::Vector< int > *)jarg1; + { + try { + (arg1)->Release(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() { + int jresult ; + int result; + + result = (int)Dali::Vector< float >::BaseType; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() { + void * jresult ; + Dali::Vector< float > *result = 0 ; + + { + try { + result = (Dali::Vector< float > *)new Dali::Vector< float >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) { + Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; + + arg1 = (Dali::Vector< float > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Vector< float > *arg1 = 0 ; + Dali::Vector< float > *result = 0 ; + + arg1 = (Dali::Vector< float > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; + Dali::Vector< float > *arg2 = 0 ; + Dali::Vector< float > *result = 0 ; + + arg1 = (Dali::Vector< float > *)jarg1; + arg2 = (Dali::Vector< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) { + void * jresult ; + Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; + Dali::Vector< float >::Iterator result; + + arg1 = (Dali::Vector< float > *)jarg1; + { + try { + result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) { + void * jresult ; + Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; + Dali::Vector< float >::Iterator result; + + arg1 = (Dali::Vector< float > *)jarg1; + { + try { + result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; + Dali::Vector< float >::SizeType arg2 ; + Dali::Vector< float >::ItemType *result = 0 ; + + arg1 = (Dali::Vector< float > *)jarg1; + arg2 = (Dali::Vector< float >::SizeType)jarg2; + { + try { + result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) { + Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; + Dali::Vector< float >::ItemType *arg2 = 0 ; + Dali::Vector< float >::ItemType temp2 ; + + arg1 = (Dali::Vector< float > *)jarg1; + temp2 = (Dali::Vector< float >::ItemType)jarg2; + arg2 = &temp2; + { + try { + (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) { + Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; + Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ; + Dali::Vector< float >::ItemType *arg3 = 0 ; + Dali::Vector< float >::ItemType temp3 ; + + arg1 = (Dali::Vector< float > *)jarg1; + arg2 = (Dali::Vector< float >::Iterator)jarg2; + temp3 = (Dali::Vector< float >::ItemType)jarg3; + arg3 = &temp3; + { + try { + (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { + Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; + Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ; + Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ; + Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ; + + arg1 = (Dali::Vector< float > *)jarg1; + arg2 = (Dali::Vector< float >::Iterator)jarg2; + arg3 = (Dali::Vector< float >::Iterator)jarg3; + arg4 = (Dali::Vector< float >::Iterator)jarg4; + { + try { + (arg1)->Insert(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) { + Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; + Dali::Vector< float >::SizeType arg2 ; + + arg1 = (Dali::Vector< float > *)jarg1; + arg2 = (Dali::Vector< float >::SizeType)jarg2; + { + try { + (arg1)->Reserve(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + +//// ========================= end of part 2 ============================= + +//// ========================== start part 3 =============================== + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) { + Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; + Dali::Vector< float >::SizeType arg2 ; + + arg1 = (Dali::Vector< float > *)jarg1; + arg2 = (Dali::Vector< float >::SizeType)jarg2; + { + try { + (arg1)->Resize(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) { + Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; + Dali::Vector< float >::SizeType arg2 ; + Dali::Vector< float >::ItemType *arg3 = 0 ; + Dali::Vector< float >::ItemType temp3 ; + + arg1 = (Dali::Vector< float > *)jarg1; + arg2 = (Dali::Vector< float >::SizeType)jarg2; + temp3 = (Dali::Vector< float >::ItemType)jarg3; + arg3 = &temp3; + { + try { + (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; + Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ; + Dali::Vector< float >::Iterator result; + + arg1 = (Dali::Vector< float > *)jarg1; + arg2 = (Dali::Vector< float >::Iterator)jarg2; + { + try { + result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) { + void * jresult ; + Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; + Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ; + Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ; + Dali::Vector< float >::Iterator result; + + arg1 = (Dali::Vector< float > *)jarg1; + arg2 = (Dali::Vector< float >::Iterator)jarg2; + arg3 = (Dali::Vector< float >::Iterator)jarg3; + { + try { + result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) { + Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; + Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ; + + arg1 = (Dali::Vector< float > *)jarg1; + arg2 = (Dali::Vector< float >::Iterator)jarg2; + { + try { + (arg1)->Remove(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) { + Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; + Dali::Vector< float > *arg2 = 0 ; + + arg1 = (Dali::Vector< float > *)jarg1; + arg2 = (Dali::Vector< float > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0); + return ; + } + { + try { + (arg1)->Swap(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) { + Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; + + arg1 = (Dali::Vector< float > *)jarg1; + { + try { + (arg1)->Clear(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) { + Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; + + arg1 = (Dali::Vector< float > *)jarg1; + { + try { + (arg1)->Release(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() { + int jresult ; + int result; + + result = (int)Dali::Vector< unsigned char >::BaseType; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() { + void * jresult ; + Dali::Vector< unsigned char > *result = 0 ; + + { + try { + result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) { + Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; + + arg1 = (Dali::Vector< unsigned char > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Vector< unsigned char > *arg1 = 0 ; + Dali::Vector< unsigned char > *result = 0 ; + + arg1 = (Dali::Vector< unsigned char > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; + Dali::Vector< unsigned char > *arg2 = 0 ; + Dali::Vector< unsigned char > *result = 0 ; + + arg1 = (Dali::Vector< unsigned char > *)jarg1; + arg2 = (Dali::Vector< unsigned char > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) { + void * jresult ; + Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; + Dali::Vector< unsigned char >::Iterator result; + + arg1 = (Dali::Vector< unsigned char > *)jarg1; + { + try { + result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) { + void * jresult ; + Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; + Dali::Vector< unsigned char >::Iterator result; + + arg1 = (Dali::Vector< unsigned char > *)jarg1; + { + try { + result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; + Dali::Vector< unsigned char >::SizeType arg2 ; + Dali::Vector< unsigned char >::ItemType *result = 0 ; + + arg1 = (Dali::Vector< unsigned char > *)jarg1; + arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2; + { + try { + result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) { + Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; + Dali::Vector< unsigned char >::ItemType *arg2 = 0 ; + Dali::Vector< unsigned char >::ItemType temp2 ; + + arg1 = (Dali::Vector< unsigned char > *)jarg1; + temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2; + arg2 = &temp2; + { + try { + (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) { + Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; + Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ; + Dali::Vector< unsigned char >::ItemType *arg3 = 0 ; + Dali::Vector< unsigned char >::ItemType temp3 ; + + arg1 = (Dali::Vector< unsigned char > *)jarg1; + arg2 = jarg2; + temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3; + arg3 = &temp3; + { + try { + (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + + + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) { + Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; + Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ; + Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ; + Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ; + + arg1 = (Dali::Vector< unsigned char > *)jarg1; + arg2 = jarg2; + arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3; + arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4; + { + try { + (arg1)->Insert(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + + + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) { + Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; + Dali::Vector< unsigned char >::SizeType arg2 ; + + arg1 = (Dali::Vector< unsigned char > *)jarg1; + arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2; + { + try { + (arg1)->Reserve(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) { + Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; + Dali::Vector< unsigned char >::SizeType arg2 ; + + arg1 = (Dali::Vector< unsigned char > *)jarg1; + arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2; + { + try { + (arg1)->Resize(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) { + Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; + Dali::Vector< unsigned char >::SizeType arg2 ; + Dali::Vector< unsigned char >::ItemType *arg3 = 0 ; + Dali::Vector< unsigned char >::ItemType temp3 ; + + arg1 = (Dali::Vector< unsigned char > *)jarg1; + arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2; + temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3; + arg3 = &temp3; + { + try { + (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) { + void * jresult ; + Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; + Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ; + Dali::Vector< unsigned char >::Iterator result; + + arg1 = (Dali::Vector< unsigned char > *)jarg1; + arg2 = jarg2; + { + try { + result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) { + void * jresult ; + Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; + Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ; + Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ; + Dali::Vector< unsigned char >::Iterator result; + + arg1 = (Dali::Vector< unsigned char > *)jarg1; + arg2 = jarg2; + arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3; + { + try { + result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) { + Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; + Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ; + + arg1 = (Dali::Vector< unsigned char > *)jarg1; + arg2 = jarg2; + { + try { + (arg1)->Remove(arg2); + } CALL_CATCH_EXCEPTION(); + } + + + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) { + Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; + Dali::Vector< unsigned char > *arg2 = 0 ; + + arg1 = (Dali::Vector< unsigned char > *)jarg1; + arg2 = (Dali::Vector< unsigned char > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0); + return ; + } + { + try { + (arg1)->Swap(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) { + Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; + + arg1 = (Dali::Vector< unsigned char > *)jarg1; + { + try { + (arg1)->Clear(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) { + Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; + + arg1 = (Dali::Vector< unsigned char > *)jarg1; + { + try { + (arg1)->Release(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() { + int jresult ; + int result; + + result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() { + void * jresult ; + Dali::Vector< Dali::Uint16Pair > *result = 0 ; + + { + try { + result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) { + Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; + + arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ; + Dali::Vector< Dali::Uint16Pair > *result = 0 ; + + arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; + Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ; + Dali::Vector< Dali::Uint16Pair > *result = 0 ; + + arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; + arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) { + void * jresult ; + Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; + Dali::Vector< Dali::Uint16Pair >::Iterator result; + + arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; + { + try { + result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) { + void * jresult ; + Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; + Dali::Vector< Dali::Uint16Pair >::Iterator result; + + arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; + { + try { + result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; + Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ; + Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ; + + arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; + arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2; + { + try { + result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) { + Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; + Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ; + + arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; + arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0); + return ; + } + { + try { + (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { + Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; + Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ; + Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ; + + arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; + arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2; + arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0); + return ; + } + { + try { + (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { + Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; + Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ; + Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ; + Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ; + + arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; + arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2; + arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3; + arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4; + { + try { + (arg1)->Insert(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) { + Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; + Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ; + + arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; + arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2; + { + try { + (arg1)->Reserve(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) { + Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; + Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ; + + arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; + arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2; + { + try { + (arg1)->Resize(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) { + Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; + Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ; + Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ; + + arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; + arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2; + arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0); + return ; + } + { + try { + (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; + Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ; + Dali::Vector< Dali::Uint16Pair >::Iterator result; + + arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; + arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2; + { + try { + result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) { + void * jresult ; + Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; + Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ; + Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ; + Dali::Vector< Dali::Uint16Pair >::Iterator result; + + arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; + arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2; + arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3; + { + try { + result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) { + Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; + Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ; + + arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; + arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2; + { + try { + (arg1)->Remove(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) { + Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; + Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ; + + arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; + arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0); + return ; + } + { + try { + (arg1)->Swap(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) { + Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; + + arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; + { + try { + (arg1)->Clear(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) { + Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; + + arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; + { + try { + (arg1)->Release(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() { + void * jresult ; + Dali::Signal< void () > *result = 0 ; + + { + try { + result = (Dali::Signal< void () > *)new Dali::Signal< void () >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) { + Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; + + arg1 = (Dali::Signal< void () > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void () > *)jarg1; + { + try { + result = (bool)((Dali::Signal< void () > const *)arg1)->Empty(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void () > *)jarg1; + { + try { + result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) { + Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; + void (*arg2)() = (void (*)()) 0 ; + + arg1 = (Dali::Signal< void () > *)jarg1; + arg2 = (void (*)())jarg2; + { + try { + (arg1)->Connect(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; + void (*arg2)() = (void (*)()) 0 ; + + arg1 = (Dali::Signal< void () > *)jarg1; + arg2 = (void (*)())jarg2; + { + try { + (arg1)->Disconnect(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) { + Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; + Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ; + Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ; + + arg1 = (Dali::Signal< void () > *)jarg1; + arg2 = (Dali::ConnectionTrackerInterface *)jarg2; + arg3 = (Dali::FunctorDelegate *)jarg3; + { + try { + (arg1)->Connect(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) { + Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; + + arg1 = (Dali::Signal< void () > *)jarg1; + { + try { + (arg1)->Emit(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (float) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (float) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ; + void (*arg2)(float) = (void (*)(float)) 0 ; + + arg1 = (Dali::Signal< void (float) > *)jarg1; + arg2 = (void (*)(float))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ; + void (*arg2)(float) = (void (*)(float)) 0 ; + + arg1 = (Dali::Signal< void (float) > *)jarg1; + arg2 = (void (*)(float))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) { + Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ; + float arg2 ; + + arg1 = (Dali::Signal< void (float) > *)jarg1; + arg2 = (float)jarg2; + { + try { + Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() { + void * jresult ; + Dali::Signal< void (float) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) { + Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ; + + arg1 = (Dali::Signal< void (float) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ; + void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ; + + arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1; + arg2 = (void (*)(Dali::BaseHandle))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ; + void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ; + + arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1; + arg2 = (void (*)(Dali::BaseHandle))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ; + Dali::BaseHandle arg2 ; + Dali::BaseHandle *argp2 ; + + arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1; + argp2 = (Dali::BaseHandle *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0); + return ; + } + arg2 = *argp2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() { + void * jresult ; + Dali::Signal< void (Dali::BaseHandle) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) { + Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ; + void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1; + arg2 = (void (*)(Dali::PropertyNotification &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ; + void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1; + arg2 = (void (*)(Dali::PropertyNotification &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ; + Dali::PropertyNotification *arg2 = 0 ; + + arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1; + arg2 = (Dali::PropertyNotification *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0); + return ; + } + { + try { + Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() { + void * jresult ; + Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) { + Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() { + void * jresult ; + Dali::Signal< void (Dali::RenderTask &) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) { + Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ; + void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1; + arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ; + void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1; + arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) { + Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ; + Dali::Actor arg2 ; + Dali::LongPressGesture *arg3 = 0 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::LongPressGesture *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0); + return ; + } + { + try { + Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() { + void * jresult ; + Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) { + Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ; + void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1; + arg2 = (void (*)(Dali::KeyEvent const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ; + void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1; + arg2 = (void (*)(Dali::KeyEvent const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ; + Dali::KeyEvent *arg2 = 0 ; + + arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1; + arg2 = (Dali::KeyEvent *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0); + return ; + } + { + try { + Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() { + void * jresult ; + Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) { + Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ; + void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1; + arg2 = (void (*)(Dali::WheelEvent const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ; + void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1; + arg2 = (void (*)(Dali::WheelEvent const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ; + Dali::WheelEvent *arg2 = 0 ; + + arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1; + arg2 = (Dali::WheelEvent *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0); + return ; + } + { + try { + Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() { + void * jresult ; + Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) { + Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() { + void * jresult ; + std::pair< Dali::Radian,Dali::Radian > *result = 0 ; + + { + try { + result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Radian arg1 ; + Dali::Radian arg2 ; + Dali::Radian *argp1 ; + Dali::Radian *argp2 ; + std::pair< Dali::Radian,Dali::Radian > *result = 0 ; + + argp1 = (Dali::Radian *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg1 = *argp1; + argp2 = (Dali::Radian *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) { + void * jresult ; + std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ; + std::pair< Dali::Radian,Dali::Radian > *result = 0 ; + + arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0); + return 0; + } + { + try { + result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) { + std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ; + Dali::Radian *arg2 = (Dali::Radian *) 0 ; + + arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1; + arg2 = (Dali::Radian *)jarg2; + if (arg1) (arg1)->first = *arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) { + void * jresult ; + std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ; + Dali::Radian *result = 0 ; + + arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1; + result = (Dali::Radian *)& ((arg1)->first); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) { + std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ; + Dali::Radian *arg2 = (Dali::Radian *) 0 ; + + arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1; + arg2 = (Dali::Radian *)jarg2; + if (arg1) (arg1)->second = *arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) { + void * jresult ; + std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ; + Dali::Radian *result = 0 ; + + arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1; + result = (Dali::Radian *)& ((arg1)->second); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) { + std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ; + + arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ; + void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1; + arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ; + void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1; + arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) { + Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ; + Dali::Actor arg2 ; + Dali::PanGesture *arg3 = 0 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::PanGesture *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0); + return ; + } + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() { + void * jresult ; + Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) { + Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ; + void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1; + arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ; + void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1; + arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) { + Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ; + Dali::Actor arg2 ; + Dali::PinchGesture *arg3 = 0 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::PinchGesture *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0); + return ; + } + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() { + void * jresult ; + Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) { + Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ; + void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1; + arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ; + void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1; + arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) { + Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ; + Dali::Actor arg2 ; + Dali::TapGesture *arg3 = 0 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::TapGesture *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0); + return ; + } + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() { + void * jresult ; + Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) { + Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ; + std::size_t result = 0; + + arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *)arg1); + }CALL_CATCH_EXCEPTION(0); + } + jresult = (unsigned long)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ; + void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1; + arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ; + void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1; + arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) { + Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ; + Dali::Actor arg2 ; + //bool arg3 ; + Dali::LayoutDirection::Type arg4 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + //arg3 = jarg3 ? true : false; + arg4 = (Dali::LayoutDirection::Type)jarg4; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() { + void * jresult ; + Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) { + Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_director_connect(void *objarg, SwigDirector_ViewImpl::SWIG_Callback0_t callback0, SwigDirector_ViewImpl::SWIG_Callback1_t callback1, SwigDirector_ViewImpl::SWIG_Callback2_t callback2, SwigDirector_ViewImpl::SWIG_Callback3_t callback3, SwigDirector_ViewImpl::SWIG_Callback4_t callback4, SwigDirector_ViewImpl::SWIG_Callback5_t callback5, SwigDirector_ViewImpl::SWIG_Callback6_t callback6, SwigDirector_ViewImpl::SWIG_Callback9_t callback9, SwigDirector_ViewImpl::SWIG_Callback11_t callback11, SwigDirector_ViewImpl::SWIG_Callback12_t callback12, SwigDirector_ViewImpl::SWIG_Callback13_t callback13, SwigDirector_ViewImpl::SWIG_Callback14_t callback14, SwigDirector_ViewImpl::SWIG_Callback15_t callback15, SwigDirector_ViewImpl::SWIG_Callback16_t callback16, SwigDirector_ViewImpl::SWIG_Callback17_t callback17, SwigDirector_ViewImpl::SWIG_Callback18_t callback18, SwigDirector_ViewImpl::SWIG_Callback19_t callback19, SwigDirector_ViewImpl::SWIG_Callback20_t callback20, SwigDirector_ViewImpl::SWIG_Callback21_t callback21, SwigDirector_ViewImpl::SWIG_Callback24_t callback24, SwigDirector_ViewImpl::SWIG_Callback25_t callback25, SwigDirector_ViewImpl::SWIG_Callback26_t callback26, SwigDirector_ViewImpl::SWIG_Callback28_t callback28, SwigDirector_ViewImpl::SWIG_Callback29_t callback29, SwigDirector_ViewImpl::SWIG_Callback30_t callback30, SwigDirector_ViewImpl::SWIG_Callback31_t callback31, SwigDirector_ViewImpl::SWIG_Callback32_t callback32, SwigDirector_ViewImpl::SWIG_Callback33_t callback33, SwigDirector_ViewImpl::SWIG_Callback34_t callback34, SwigDirector_ViewImpl::SWIG_Callback35_t callback35, SwigDirector_ViewImpl::SWIG_Callback36_t callback36, SwigDirector_ViewImpl::SWIG_Callback37_t callback37, SwigDirector_ViewImpl::SWIG_Callback38_t callback38, SwigDirector_ViewImpl::SWIG_Callback39_t callback39, SwigDirector_ViewImpl::SWIG_Callback40_t callback40) { + Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg; + SwigDirector_ViewImpl *director = dynamic_cast(obj); + if (director) { + director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback9, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback24, callback25, callback26, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_director_connect(void *objarg, SwigDirector_ItemFactory::SWIG_Callback0_t callback0, SwigDirector_ItemFactory::SWIG_Callback1_t callback1, SwigDirector_ItemFactory::SWIG_Callback2_t callback2) { + Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg; + SwigDirector_ItemFactory *director = dynamic_cast(obj); + if (director) { + director->swig_connect_director(callback0, callback1, callback2); + } +} + + +//// ========================= end of part 3 ============================= + +//// ========================== start part 4 ============================= + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) { + Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg; + SwigDirector_FrameCallbackInterface *director = dynamic_cast(obj); + if (director) { + director->swig_connect_director(callback0); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() { + void * jresult ; + Dali::FrameCallbackInterface *result = 0 ; + + { + try { + result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) { + Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg; + SwigDirector_CustomAlgorithmInterface *director = dynamic_cast(obj); + if (director) { + director->swig_connect_director(callback0); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_director_connect(void *objarg, SwigDirector_WidgetImpl::SWIG_Callback0_t callback0, SwigDirector_WidgetImpl::SWIG_Callback1_t callback1, SwigDirector_WidgetImpl::SWIG_Callback2_t callback2, SwigDirector_WidgetImpl::SWIG_Callback3_t callback3, SwigDirector_WidgetImpl::SWIG_Callback4_t callback4, SwigDirector_WidgetImpl::SWIG_Callback5_t callback5, SwigDirector_WidgetImpl::SWIG_Callback6_t callback6, SwigDirector_WidgetImpl::SWIG_Callback7_t callback7) { + SwigDirector_WidgetImpl *director = static_cast(objarg); + if (director) { + director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() { + void * jresult ; + SwigDirector_WidgetImpl* result; + { + try { + result = new SwigDirector_WidgetImpl(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) { + void * jresult ; + Dali::Widget *arg1 = 0 ; + SwigDirector_WidgetImpl *result = 0 ; + + arg1 = (Dali::Widget *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0); + return 0; + } + { + try { + result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void*) result; + return jresult; +} + + + +SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) { + return (Dali::SignalObserver *)jarg1; +} + +SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) { + return (Dali::ConnectionTrackerInterface *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) { + return (Dali::Handle *)jarg1; +} + +SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) { + return (Dali::Handle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) { + return (Dali::Handle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Key_SWIGUpcast(Dali::KeyEvent *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Gesture_SWIGUpcast(Dali::Gesture *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) { + return (Dali::Handle *)jarg1; +} + +SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) { + return (Dali::GestureDetector *)jarg1; +} + +SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) { + return (Dali::Gesture *)jarg1; +} + + +SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) { + return (Dali::RefObject *)jarg1; +} + +SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) { + return (Dali::Actor *)jarg1; +} + +SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) { + return (Dali::GestureDetector *)jarg1; +} + +SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) { + return (Dali::Gesture *)jarg1; +} + +SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) { + return (Dali::GestureDetector *)jarg1; +} + +SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) { + return (Dali::Gesture *)jarg1; +} + +SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) { + return (Dali::GestureDetector *)jarg1; +} + +SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) { + return (Dali::Gesture *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) { + return (Dali::Handle *)jarg1; +} + +SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) { + return (Dali::Handle *)jarg1; +} + +SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) { + return (Dali::Handle *)jarg1; +} + +SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) { + return (Dali::RefObject *)jarg1; +} + +SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) { + return (Dali::Actor *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) { + const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1); + char * jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) { + bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2); + return result; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) { + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + + arg1 = (std::vector< unsigned int > *)jarg1; + { + try { + (arg1)->clear(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) { + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + unsigned int *arg2 = 0 ; + unsigned int temp2 ; + + arg1 = (std::vector< unsigned int > *)jarg1; + temp2 = (unsigned int)jarg2; + arg2 = &temp2; + { + try { + (arg1)->push_back((unsigned int const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) { + unsigned long jresult ; + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + std::vector< unsigned int >::size_type result; + + arg1 = (std::vector< unsigned int > *)jarg1; + { + try { + result = ((std::vector< unsigned int > const *)arg1)->size(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) { + unsigned long jresult ; + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + std::vector< unsigned int >::size_type result; + + arg1 = (std::vector< unsigned int > *)jarg1; + { + try { + result = ((std::vector< unsigned int > const *)arg1)->capacity(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) { + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + std::vector< unsigned int >::size_type arg2 ; + + arg1 = (std::vector< unsigned int > *)jarg1; + arg2 = (std::vector< unsigned int >::size_type)jarg2; + { + try { + (arg1)->reserve(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() { + void * jresult ; + std::vector< unsigned int > *result = 0 ; + + { + try { + result = (std::vector< unsigned int > *)new std::vector< unsigned int >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) { + void * jresult ; + std::vector< unsigned int > *arg1 = 0 ; + std::vector< unsigned int > *result = 0 ; + + arg1 = (std::vector< unsigned int > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0); + return 0; + } + { + try { + result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) { + void * jresult ; + int arg1 ; + std::vector< unsigned int > *result = 0 ; + + arg1 = (int)jarg1; + { + try { + try { + result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) { + unsigned int jresult ; + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + int arg2 ; + unsigned int result; + + arg1 = (std::vector< unsigned int > *)jarg1; + arg2 = (int)jarg2; + { + try { + try { + result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) { + unsigned int jresult ; + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + int arg2 ; + unsigned int *result = 0 ; + + arg1 = (std::vector< unsigned int > *)jarg1; + arg2 = (int)jarg2; + { + try { + try { + result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = *result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) { + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + int arg2 ; + unsigned int *arg3 = 0 ; + unsigned int temp3 ; + + arg1 = (std::vector< unsigned int > *)jarg1; + arg2 = (int)jarg2; + temp3 = (unsigned int)jarg3; + arg3 = &temp3; + { + try { + try { + std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) { + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + std::vector< unsigned int > *arg2 = 0 ; + + arg1 = (std::vector< unsigned int > *)jarg1; + arg2 = (std::vector< unsigned int > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0); + return ; + } + { + try { + std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) { + void * jresult ; + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + int arg2 ; + int arg3 ; + std::vector< unsigned int > *result = 0 ; + + arg1 = (std::vector< unsigned int > *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + { + try { + try { + result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + catch(std::invalid_argument &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) { + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + int arg2 ; + unsigned int *arg3 = 0 ; + unsigned int temp3 ; + + arg1 = (std::vector< unsigned int > *)jarg1; + arg2 = (int)jarg2; + temp3 = (unsigned int)jarg3; + arg3 = &temp3; + { + try { + try { + std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) { + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + int arg2 ; + std::vector< unsigned int > *arg3 = 0 ; + + arg1 = (std::vector< unsigned int > *)jarg1; + arg2 = (int)jarg2; + arg3 = (std::vector< unsigned int > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0); + return ; + } + { + try { + try { + std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) { + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + int arg2 ; + + arg1 = (std::vector< unsigned int > *)jarg1; + arg2 = (int)jarg2; + { + try { + try { + std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) { + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = (std::vector< unsigned int > *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + { + try { + try { + std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + catch(std::invalid_argument &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) { + void * jresult ; + unsigned int *arg1 = 0 ; + int arg2 ; + unsigned int temp1 ; + std::vector< unsigned int > *result = 0 ; + + temp1 = (unsigned int)jarg1; + arg1 = &temp1; + arg2 = (int)jarg2; + { + try { + try { + result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) { + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + + arg1 = (std::vector< unsigned int > *)jarg1; + { + try { + std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) { + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = (std::vector< unsigned int > *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + { + try { + try { + std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + catch(std::invalid_argument &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) { + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + int arg2 ; + std::vector< unsigned int > *arg3 = 0 ; + + arg1 = (std::vector< unsigned int > *)jarg1; + arg2 = (int)jarg2; + arg3 = (std::vector< unsigned int > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0); + return ; + } + { + try { + try { + std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) { + bool jresult ; + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + unsigned int *arg2 = 0 ; + unsigned int temp2 ; + bool result; + + arg1 = (std::vector< unsigned int > *)jarg1; + temp2 = (unsigned int)jarg2; + arg2 = &temp2; + { + try { + result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) { + int jresult ; + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + unsigned int *arg2 = 0 ; + unsigned int temp2 ; + int result; + + arg1 = (std::vector< unsigned int > *)jarg1; + temp2 = (unsigned int)jarg2; + arg2 = &temp2; + { + try { + result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) { + int jresult ; + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + unsigned int *arg2 = 0 ; + unsigned int temp2 ; + int result; + + arg1 = (std::vector< unsigned int > *)jarg1; + temp2 = (unsigned int)jarg2; + arg2 = &temp2; + { + try { + result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) { + bool jresult ; + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + unsigned int *arg2 = 0 ; + unsigned int temp2 ; + bool result; + + arg1 = (std::vector< unsigned int > *)jarg1; + temp2 = (unsigned int)jarg2; + arg2 = &temp2; + { + try { + result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) { + std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; + + arg1 = (std::vector< unsigned int > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() { + void * jresult ; + std::pair< unsigned int,Dali::Actor > *result = 0 ; + + { + try { + result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) { + void * jresult ; + unsigned int arg1 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + std::pair< unsigned int,Dali::Actor > *result = 0 ; + + arg1 = (unsigned int)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) { + void * jresult ; + std::pair< unsigned int,Dali::Actor > *arg1 = 0 ; + std::pair< unsigned int,Dali::Actor > *result = 0 ; + + arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0); + return 0; + } + { + try { + result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) { + std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ; + unsigned int arg2 ; + + arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1; + arg2 = (unsigned int)jarg2; + if (arg1) (arg1)->first = arg2; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) { + unsigned int jresult ; + std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ; + unsigned int result; + + arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1; + result = (unsigned int) ((arg1)->first); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) { + std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ; + Dali::Actor *arg2 = (Dali::Actor *) 0 ; + + arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1; + arg2 = (Dali::Actor *)jarg2; + if (arg1) (arg1)->second = *arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) { + void * jresult ; + std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ; + Dali::Actor *result = 0 ; + + arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1; + result = (Dali::Actor *)& ((arg1)->second); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) { + std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ; + + arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) { + std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; + + arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; + { + try { + (arg1)->clear(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) { + std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; + std::pair< unsigned int,Dali::Actor > *arg2 = 0 ; + + arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; + arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0); + return ; + } + { + try { + (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) { + unsigned long jresult ; + std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; + std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result; + + arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; + { + try { + result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) { + unsigned long jresult ; + std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; + std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result; + + arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; + { + try { + result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) { + std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; + std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ; + + arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; + arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2; + { + try { + (arg1)->reserve(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() { + void * jresult ; + std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ; + + { + try { + result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) { + void * jresult ; + std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ; + std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ; + + arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0); + return 0; + } + { + try { + result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >((std::vector< std::pair< unsigned int,Dali::Actor > > const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) { + void * jresult ; + int arg1 ; + std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ; + + arg1 = (int)jarg1; + { + try { + try { + result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(arg1); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) { + void * jresult ; + std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; + int arg2 ; + std::pair< unsigned int,Dali::Actor > result; + + arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; + arg2 = (int)jarg2; + { + try { + try { + result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) { + void * jresult ; + std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; + int arg2 ; + std::pair< unsigned int,Dali::Actor > *result = 0 ; + + arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; + arg2 = (int)jarg2; + { + try { + try { + result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) { + std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; + int arg2 ; + std::pair< unsigned int,Dali::Actor > *arg3 = 0 ; + + arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; + arg2 = (int)jarg2; + arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0); + return ; + } + { + try { + try { + std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(arg1,arg2,(std::pair< unsigned int,Dali::Actor > const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) { + std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; + std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ; + + arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; + arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0); + return ; + } + { + try { + std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(arg1,(std::vector< std::pair< unsigned int,Dali::Actor > > const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) { + void * jresult ; + std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; + int arg2 ; + int arg3 ; + std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ; + + arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + { + try { + try { + result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + catch(std::invalid_argument &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) { + std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; + int arg2 ; + std::pair< unsigned int,Dali::Actor > *arg3 = 0 ; + + arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; + arg2 = (int)jarg2; + arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0); + return ; + } + { + try { + try { + std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(arg1,arg2,(std::pair< unsigned int,Dali::Actor > const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) { + std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; + int arg2 ; + std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ; + + arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; + arg2 = (int)jarg2; + arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0); + return ; + } + { + try { + try { + std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::pair< unsigned int,Dali::Actor > > const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) { + std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; + int arg2 ; + + arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; + arg2 = (int)jarg2; + { + try { + try { + std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) { + std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + { + try { + try { + std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + catch(std::invalid_argument &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) { + void * jresult ; + std::pair< unsigned int,Dali::Actor > *arg1 = 0 ; + int arg2 ; + std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ; + + arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0); + return 0; + } + arg2 = (int)jarg2; + { + try { + try { + result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat((std::pair< unsigned int,Dali::Actor > const &)*arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) { + std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; + + arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; + { + try { + std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) { + std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + { + try { + try { + std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + catch(std::invalid_argument &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) { + std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; + int arg2 ; + std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ; + + arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; + arg2 = (int)jarg2; + arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0); + return ; + } + { + try { + try { + std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(arg1,arg2,(std::vector< std::pair< unsigned int,Dali::Actor > > const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) { + std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; + + arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) { + std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; + + arg1 = (std::vector< Dali::Actor > *)jarg1; + { + try { + (arg1)->clear(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) { + std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; + Dali::Actor *arg2 = 0 ; + + arg1 = (std::vector< Dali::Actor > *)jarg1; + arg2 = (Dali::Actor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); + return ; + } + { + try { + (arg1)->push_back((Dali::Actor const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) { + unsigned long jresult ; + std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; + std::vector< Dali::Actor >::size_type result; + + arg1 = (std::vector< Dali::Actor > *)jarg1; + { + try { + result = ((std::vector< Dali::Actor > const *)arg1)->size(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) { + unsigned long jresult ; + std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; + std::vector< Dali::Actor >::size_type result; + + arg1 = (std::vector< Dali::Actor > *)jarg1; + { + try { + result = ((std::vector< Dali::Actor > const *)arg1)->capacity(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) { + std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; + std::vector< Dali::Actor >::size_type arg2 ; + + arg1 = (std::vector< Dali::Actor > *)jarg1; + arg2 = (std::vector< Dali::Actor >::size_type)jarg2; + { + try { + (arg1)->reserve(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() { + void * jresult ; + std::vector< Dali::Actor > *result = 0 ; + + { + try { + result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) { + void * jresult ; + std::vector< Dali::Actor > *arg1 = 0 ; + std::vector< Dali::Actor > *result = 0 ; + + arg1 = (std::vector< Dali::Actor > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0); + return 0; + } + { + try { + result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) { + void * jresult ; + int arg1 ; + std::vector< Dali::Actor > *result = 0 ; + + arg1 = (int)jarg1; + { + try { + try { + result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) { + void * jresult ; + std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; + int arg2 ; + Dali::Actor result; + + arg1 = (std::vector< Dali::Actor > *)jarg1; + arg2 = (int)jarg2; + { + try { + try { + result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) { + void * jresult ; + std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; + int arg2 ; + Dali::Actor *result = 0 ; + + arg1 = (std::vector< Dali::Actor > *)jarg1; + arg2 = (int)jarg2; + { + try { + try { + result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) { + std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; + int arg2 ; + Dali::Actor *arg3 = 0 ; + + arg1 = (std::vector< Dali::Actor > *)jarg1; + arg2 = (int)jarg2; + arg3 = (Dali::Actor *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); + return ; + } + { + try { + try { + std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) { + std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; + std::vector< Dali::Actor > *arg2 = 0 ; + + arg1 = (std::vector< Dali::Actor > *)jarg1; + arg2 = (std::vector< Dali::Actor > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0); + return ; + } + { + try { + std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) { + void * jresult ; + std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; + int arg2 ; + int arg3 ; + std::vector< Dali::Actor > *result = 0 ; + + arg1 = (std::vector< Dali::Actor > *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + { + try { + try { + result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + catch(std::invalid_argument &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) { + std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; + int arg2 ; + Dali::Actor *arg3 = 0 ; + + arg1 = (std::vector< Dali::Actor > *)jarg1; + arg2 = (int)jarg2; + arg3 = (Dali::Actor *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); + return ; + } + { + try { + try { + std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) { + std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; + int arg2 ; + std::vector< Dali::Actor > *arg3 = 0 ; + + arg1 = (std::vector< Dali::Actor > *)jarg1; + arg2 = (int)jarg2; + arg3 = (std::vector< Dali::Actor > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0); + return ; + } + { + try { + try { + std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) { + std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; + int arg2 ; + + arg1 = (std::vector< Dali::Actor > *)jarg1; + arg2 = (int)jarg2; + { + try { + try { + std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) { + std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = (std::vector< Dali::Actor > *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + { + try { + try { + std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + catch(std::invalid_argument &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) { + void * jresult ; + Dali::Actor *arg1 = 0 ; + int arg2 ; + std::vector< Dali::Actor > *result = 0 ; + + arg1 = (Dali::Actor *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); + return 0; + } + arg2 = (int)jarg2; + { + try { + try { + result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return 0; + } + + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) { + std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; + + arg1 = (std::vector< Dali::Actor > *)jarg1; + { + try { + std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) { + std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; + int arg2 ; + int arg3 ; + + arg1 = (std::vector< Dali::Actor > *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + { + try { + try { + std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + catch(std::invalid_argument &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) { + std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; + int arg2 ; + std::vector< Dali::Actor > *arg3 = 0 ; + + arg1 = (std::vector< Dali::Actor > *)jarg1; + arg2 = (int)jarg2; + arg3 = (std::vector< Dali::Actor > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0); + return ; + } + { + try { + try { + std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); + return ; + } + + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) { + std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; + + arg1 = (std::vector< Dali::Actor > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ; + void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1; + arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ; + void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1; + arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) { + Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ; + Dali::Actor arg2 ; + Dali::Actor arg3 ; + Dali::Actor *argp2 ; + Dali::Actor *argp3 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Actor *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg3 = *argp3; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() { + void * jresult ; + Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) { + Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ; + void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1; + arg2 = (void (*)(Dali::Actor,bool))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ; + void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1; + arg2 = (void (*)(Dali::Actor,bool))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, bool jarg3) { + Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ; + Dali::Actor arg2 ; + bool arg3 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + arg3 = jarg3 ? true : false; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() { + void * jresult ; + Dali::Signal< void (Dali::Actor,bool) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) { + Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_GenerateUrl(void* handle) +{ + Dali::Toolkit::ImageUrl result; + NativeImageSource* nativeImageSource = (NativeImageSource*)handle; + void *jresult; + + if (!nativeImageSource) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); + return 0; + } + { + try + { + result = Dali::Toolkit::Image::GenerateUrl(nativeImageSource); + } + catch (std::out_of_range& e) + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); + return 0; + } + catch (std::exception& e) + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); + return 0; + } + catch (Dali::DaliException e) + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); + return 0; + } + catch (...) + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); + return 0; + } + } + + jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageUrl(void* jarg1) +{ + Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0; + + imageUrl = (Dali::Toolkit::ImageUrl*)jarg1; + { + try + { + delete imageUrl; + } + catch (std::out_of_range& e) + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); + return; + } + catch (std::exception& e) + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); + return; + } + catch (Dali::DaliException e) + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); + return; + } + catch (...) + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); + return; + } + } +} + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImageUrl_Get(void* jarg1) +{ + char *jresult; + Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0; + std::string result; + + imageUrl = (Dali::Toolkit::ImageUrl*)jarg1; + { + try + { + result = imageUrl->GetUrl(); + } + catch (std::out_of_range& e) + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); + return 0; + } + catch (std::exception& e) + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); + return 0; + } + catch (Dali::DaliException e) + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); + return 0; + } + catch (...) + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); + return 0; + } + } + + jresult = SWIG_csharp_string_callback((&result)->c_str()); + return jresult; +} + + +// TODO : SwigDirector_ViewImpl + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + int arg2 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (int)jarg2; + darg = dynamic_cast(arg1); + if(!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + if(darg) { + (darg)->OnSceneConnection(arg2); + } + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + int arg2 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (int)jarg2; + darg = dynamic_cast(arg1); + if(!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + if(darg) { + (darg)->OnSceneConnectionSwigPublic(arg2); + } + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + darg = dynamic_cast(arg1); + if(!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + if(darg) { + (darg)->OnSceneDisconnection(); + } + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + darg = dynamic_cast(arg1); + if(!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + if(darg) { + (darg)->OnSceneDisconnectionSwigPublic(); + } + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Actor *arg2 = 0 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::Actor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); + return ; + } + darg = dynamic_cast(arg1); + if(!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + if(darg) { + (darg)->OnChildAdd(*arg2); + } + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Actor *arg2 = 0 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::Actor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); + return ; + } + darg = dynamic_cast(arg1); + if(!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + if(darg) { + (darg)->OnChildAddSwigPublic(*arg2); + } + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Actor *arg2 = 0 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::Actor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); + return ; + } + darg = dynamic_cast(arg1); + if(!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + if(darg) { + (darg)->OnChildRemove(*arg2); + } + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Actor *arg2 = 0 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::Actor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); + return ; + } + darg = dynamic_cast(arg1); + if(!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + if(darg) { + (darg)->OnChildRemoveSwigPublic(*arg2); + } + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Property::Index arg2 ; + Dali::Property::Value arg3 ; + Dali::Property::Value *argp3 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + argp3 = (Dali::Property::Value *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); + return ; + } + arg3 = *argp3; + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + (darg)->OnPropertySet(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Vector3 *arg2 = 0 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + (darg)->OnSizeSet((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Vector3 *arg2 = 0 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Animation *arg2 = 0 ; + Dali::Vector3 *arg3 = 0 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::Animation *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0); + return ; + } + arg3 = (Dali::Vector3 *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Animation *arg2 = 0 ; + Dali::Vector3 *arg3 = 0 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::Animation *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0); + return ; + } + arg3 = (Dali::Vector3 *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::KeyEvent *arg2 = 0 ; + SwigDirector_ViewImpl *darg = 0; + bool result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::KeyEvent *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0); + return 0; + } + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return 0; + } + { + try { + result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::KeyEvent *arg2 = 0 ; + SwigDirector_ViewImpl *darg = 0; + bool result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::KeyEvent *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0); + return 0; + } + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return 0; + } + { + try { + result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Vector2 *arg2 = 0 ; + Dali::RelayoutContainer *arg3 = 0 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + arg3 = (Dali::RelayoutContainer *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0); + return ; + } + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Vector2 *arg2 = 0 ; + Dali::RelayoutContainer *arg3 = 0 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + arg3 = (Dali::RelayoutContainer *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0); + return ; + } + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::ResizePolicy::Type arg2 ; + Dali::Dimension::Type arg3 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::ResizePolicy::Type)jarg2; + arg3 = (Dali::Dimension::Type)jarg3; + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + (darg)->OnSetResizePolicy(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::ResizePolicy::Type arg2 ; + Dali::Dimension::Type arg3 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::ResizePolicy::Type)jarg2; + arg3 = (Dali::Dimension::Type)jarg3; + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + (darg)->OnSetResizePolicySwigPublic(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + SwigDirector_ViewImpl *darg = 0; + Dali::Vector3 result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return 0; + } + { + try { + result = (darg)->GetNaturalSize(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + SwigDirector_ViewImpl *darg = 0; + Dali::Vector3 result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return 0; + } + { + try { + result = (darg)->GetNaturalSizeSwigPublic(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) { + float jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Actor *arg2 = 0 ; + Dali::Dimension::Type arg3 ; + SwigDirector_ViewImpl *darg = 0; + float result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::Actor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); + return 0; + } + arg3 = (Dali::Dimension::Type)jarg3; + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return 0; + } + { + try { + result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) { + float jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Actor *arg2 = 0 ; + Dali::Dimension::Type arg3 ; + SwigDirector_ViewImpl *darg = 0; + float result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::Actor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); + return 0; + } + arg3 = (Dali::Dimension::Type)jarg3; + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return 0; + } + { + try { + result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) { + float jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + float arg2 ; + SwigDirector_ViewImpl *darg = 0; + float result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (float)jarg2; + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return 0; + } + { + try { + result = (float)(darg)->GetHeightForWidth(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) { + float jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + float arg2 ; + SwigDirector_ViewImpl *darg = 0; + float result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (float)jarg2; + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return 0; + } + { + try { + result = (float)(darg)->GetHeightForWidthSwigPublic(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) { + float jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + float arg2 ; + SwigDirector_ViewImpl *darg = 0; + float result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (float)jarg2; + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return 0; + } + { + try { + result = (float)(darg)->GetWidthForHeight(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) { + float jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + float arg2 ; + SwigDirector_ViewImpl *darg = 0; + float result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (float)jarg2; + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return 0; + } + { + try { + result = (float)(darg)->GetWidthForHeightSwigPublic(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) { + bool jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Dimension::Type arg2 ; + SwigDirector_ViewImpl *darg = 0; + bool result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::Dimension::Type)jarg2; + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return 0; + } + { + try { + result = (bool)(darg)->RelayoutDependentOnChildren(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) { + bool jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Dimension::Type arg2 ; + SwigDirector_ViewImpl *darg = 0; + bool result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::Dimension::Type)jarg2; + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return 0; + } + { + try { + result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) { + bool jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + SwigDirector_ViewImpl *darg = 0; + bool result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return 0; + } + { + try { + result = (bool)(darg)->RelayoutDependentOnChildren(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) { + bool jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + SwigDirector_ViewImpl *darg = 0; + bool result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return 0; + } + { + try { + result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Dimension::Type arg2 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::Dimension::Type)jarg2; + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + (darg)->OnCalculateRelayoutSize(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Dimension::Type arg2 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::Dimension::Type)jarg2; + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + (darg)->OnCalculateRelayoutSizeSwigPublic(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + float arg2 ; + Dali::Dimension::Type arg3 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (float)jarg2; + arg3 = (Dali::Dimension::Type)jarg3; + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + (darg)->OnLayoutNegotiated(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + float arg2 ; + Dali::Dimension::Type arg3 ; + SwigDirector_ViewImpl *darg = 0; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (float)jarg2; + arg3 = (Dali::Dimension::Type)jarg3; + darg = dynamic_cast(arg1); + if (!darg) { + SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); + return; + } + { + try { + (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +// TODO : SwigDirector_ItemFactory + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() { + void * jresult ; + Dali::Toolkit::ItemFactory *result = 0 ; + + { + try { + result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/common/dali-wrap.h b/dali-csharp-binder/common/dali-wrap.h new file mode 100755 index 00000000..8b40df07 --- /dev/null +++ b/dali-csharp-binder/common/dali-wrap.h @@ -0,0 +1,272 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 3.0.9 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + +#ifndef SWIG_NDalic_WRAP_H +#define SWIG_NDalic_WRAP_H + +class SwigDirector_WidgetImpl : public Dali::Internal::Adaptor::Widget, public Swig::Director { + +public: + SwigDirector_WidgetImpl(); + virtual ~SwigDirector_WidgetImpl(); + virtual void OnCreate(std::string const &contentInfo, Dali::Window window); + virtual void OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type); + virtual void OnPause(); + virtual void OnResume(); + virtual void OnResize(Dali::Window window); + virtual void OnUpdate(std::string const &contentInfo, int force); + virtual void SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback); + virtual void SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback); + + typedef void (SWIGSTDCALL* SWIG_Callback0_t)(char *, void *); + typedef void (SWIGSTDCALL* SWIG_Callback1_t)(char *, int); + typedef void (SWIGSTDCALL* SWIG_Callback2_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback3_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback4_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback5_t)(char *, int); + typedef void (SWIGSTDCALL* SWIG_Callback6_t)(void *, void *); + typedef void (SWIGSTDCALL* SWIG_Callback7_t)(void *, void *); + void swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected); + +private: + SWIG_Callback0_t swig_callbackOnCreate; + SWIG_Callback1_t swig_callbackOnTerminate; + SWIG_Callback2_t swig_callbackOnPause; + SWIG_Callback3_t swig_callbackOnResume; + SWIG_Callback4_t swig_callbackOnResize; + SWIG_Callback5_t swig_callbackOnUpdate; + SWIG_Callback6_t swig_callbackSignalConnected; + SWIG_Callback7_t swig_callbackSignalDisconnected; + void swig_init_callbacks(); +}; + +class SwigDirector_ViewImpl : public Dali::Toolkit::Internal::Control, public Swig::Director { + +public: + SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags); + virtual ~SwigDirector_ViewImpl(); + virtual void OnSceneConnection(int depth); + virtual void OnSceneConnectionSwigPublic(int depth) { + Dali::Toolkit::Internal::Control::OnSceneConnection(depth); + } + virtual void OnSceneDisconnection(); + virtual void OnSceneDisconnectionSwigPublic() { + Dali::Toolkit::Internal::Control::OnSceneDisconnection(); + } + virtual void OnChildAdd(Dali::Actor &child); + virtual void OnChildAddSwigPublic(Dali::Actor &child) { + Dali::Toolkit::Internal::Control::OnChildAdd(child); + } + virtual void OnChildRemove(Dali::Actor &child); + virtual void OnChildRemoveSwigPublic(Dali::Actor &child) { + Dali::Toolkit::Internal::Control::OnChildRemove(child); + } + virtual void OnPropertySet(Dali::Property::Index index, const Dali::Property::Value& propertyValue); + virtual void OnPropertySetSwigPublic(Dali::Property::Index index, const Dali::Property::Value& propertyValue) { + Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue); + } + virtual void OnSizeSet(Dali::Vector3 const &targetSize); + virtual void OnSizeSetSwigPublic(Dali::Vector3 const &targetSize) { + Dali::Toolkit::Internal::Control::OnSizeSet(targetSize); + } + virtual void OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize); + virtual void OnSizeAnimationSwigPublic(Dali::Animation &animation, Dali::Vector3 const &targetSize) { + Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize); + } + virtual bool OnKeyEvent(Dali::KeyEvent const &event); + virtual bool OnKeyEventSwigPublic(Dali::KeyEvent const &event) { + return Dali::Toolkit::Internal::Control::OnKeyEvent(event); + } + virtual void OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container); + virtual void OnRelayoutSwigPublic(Dali::Vector2 const &size, Dali::RelayoutContainer &container) { + Dali::Toolkit::Internal::Control::OnRelayout(size,container); + } + virtual void OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension); + virtual void OnSetResizePolicySwigPublic(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) { + Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension); + } + virtual Dali::Vector3 GetNaturalSize(); + virtual Dali::Vector3 GetNaturalSizeSwigPublic() { + return Dali::Toolkit::Internal::Control::GetNaturalSize(); + } + virtual float CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension); + virtual float CalculateChildSizeSwigPublic(Dali::Actor const &child, Dali::Dimension::Type dimension) { + return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension); + } + virtual float GetHeightForWidth(float width); + virtual float GetHeightForWidthSwigPublic(float width) { + return Dali::Toolkit::Internal::Control::GetHeightForWidth(width); + } + virtual float GetWidthForHeight(float height); + virtual float GetWidthForHeightSwigPublic(float height) { + return Dali::Toolkit::Internal::Control::GetWidthForHeight(height); + } + virtual bool RelayoutDependentOnChildren(Dali::Dimension::Type dimension = Dali::Dimension::ALL_DIMENSIONS); + virtual bool RelayoutDependentOnChildrenSwigPublic(Dali::Dimension::Type dimension = Dali::Dimension::ALL_DIMENSIONS) { + return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension); + } + virtual void OnCalculateRelayoutSize(Dali::Dimension::Type dimension); + virtual void OnCalculateRelayoutSizeSwigPublic(Dali::Dimension::Type dimension) { + Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension); + } + virtual void OnLayoutNegotiated(float size, Dali::Dimension::Type dimension); + virtual void OnLayoutNegotiatedSwigPublic(float size, Dali::Dimension::Type dimension) { + Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension); + } + virtual Dali::CustomActorImpl::Extension *GetExtension(); + virtual void OnInitialize(); + virtual void OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change); + virtual bool OnAccessibilityActivated(); + virtual bool OnAccessibilityPan(Dali::PanGesture gesture); + virtual bool OnAccessibilityValueChange(bool isIncrease); + virtual bool OnAccessibilityZoom(); + virtual void OnKeyInputFocusGained(); + virtual void OnKeyInputFocusLost(); + virtual Dali::Actor GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled); + virtual void OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor); + virtual bool OnKeyboardEnter(); + virtual void OnPinch(Dali::PinchGesture const &pinch); + virtual void OnPan(Dali::PanGesture const &pan); + virtual void OnTap(Dali::TapGesture const &tap); + virtual void OnLongPress(Dali::LongPressGesture const &longPress); + virtual void SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback); + virtual void SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback); + virtual Dali::Toolkit::Internal::Control::Extension *GetControlExtension(); + + typedef void (SWIGSTDCALL* SWIG_Callback0_t)(int); + typedef void (SWIGSTDCALL* SWIG_Callback1_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback2_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback3_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback4_t)(int, void *); + typedef void (SWIGSTDCALL* SWIG_Callback5_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback6_t)(void *, void *); + typedef bool (SWIGSTDCALL* SWIG_Callback9_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback11_t)(void *, void *); + typedef void (SWIGSTDCALL* SWIG_Callback12_t)(int, int); + typedef void * (SWIGSTDCALL* SWIG_Callback13_t)(); + typedef float (SWIGSTDCALL* SWIG_Callback14_t)(void *, int); + typedef float (SWIGSTDCALL* SWIG_Callback15_t)(float); + typedef float (SWIGSTDCALL* SWIG_Callback16_t)(float); + typedef bool (SWIGSTDCALL* SWIG_Callback17_t)(int); + typedef bool (SWIGSTDCALL* SWIG_Callback18_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback19_t)(int); + typedef void (SWIGSTDCALL* SWIG_Callback20_t)(float, int); + typedef void (SWIGSTDCALL* SWIG_Callback21_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback22_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback23_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback24_t)(void *, int); + typedef bool (SWIGSTDCALL* SWIG_Callback25_t)(); + typedef bool (SWIGSTDCALL* SWIG_Callback26_t)(void *); + typedef bool (SWIGSTDCALL* SWIG_Callback28_t)(bool); + typedef bool (SWIGSTDCALL* SWIG_Callback29_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback30_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback31_t)(); + typedef void * (SWIGSTDCALL* SWIG_Callback32_t)(void *, int, bool); + typedef void (SWIGSTDCALL* SWIG_Callback33_t)(void *); + typedef bool (SWIGSTDCALL* SWIG_Callback34_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback35_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback36_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback37_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback38_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback39_t)(void *, void *); + typedef void (SWIGSTDCALL* SWIG_Callback40_t)(void *, void *); + void swig_connect_director(SWIG_Callback0_t callbackOnSceneConnection, SWIG_Callback1_t callbackOnSceneDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected); + +private: + SWIG_Callback0_t swig_callbackOnSceneConnection; + SWIG_Callback1_t swig_callbackOnSceneDisconnection; + SWIG_Callback2_t swig_callbackOnChildAdd; + SWIG_Callback3_t swig_callbackOnChildRemove; + SWIG_Callback4_t swig_callbackOnPropertySet; + SWIG_Callback5_t swig_callbackOnSizeSet; + SWIG_Callback6_t swig_callbackOnSizeAnimation; + SWIG_Callback9_t swig_callbackOnKeyEvent; + SWIG_Callback11_t swig_callbackOnRelayout; + SWIG_Callback12_t swig_callbackOnSetResizePolicy; + SWIG_Callback13_t swig_callbackGetNaturalSize; + SWIG_Callback14_t swig_callbackCalculateChildSize; + SWIG_Callback15_t swig_callbackGetHeightForWidth; + SWIG_Callback16_t swig_callbackGetWidthForHeight; + SWIG_Callback17_t swig_callbackRelayoutDependentOnChildren__SWIG_0; + SWIG_Callback18_t swig_callbackRelayoutDependentOnChildren__SWIG_1; + SWIG_Callback19_t swig_callbackOnCalculateRelayoutSize; + SWIG_Callback20_t swig_callbackOnLayoutNegotiated; + SWIG_Callback21_t swig_callbackOnInitialize; + SWIG_Callback24_t swig_callbackOnStyleChange; + SWIG_Callback25_t swig_callbackOnAccessibilityActivated; + SWIG_Callback26_t swig_callbackOnAccessibilityPan; + SWIG_Callback28_t swig_callbackOnAccessibilityValueChange; + SWIG_Callback29_t swig_callbackOnAccessibilityZoom; + SWIG_Callback30_t swig_callbackOnKeyInputFocusGained; + SWIG_Callback31_t swig_callbackOnKeyInputFocusLost; + SWIG_Callback32_t swig_callbackGetNextKeyboardFocusableActor; + SWIG_Callback33_t swig_callbackOnKeyboardFocusChangeCommitted; + SWIG_Callback34_t swig_callbackOnKeyboardEnter; + SWIG_Callback35_t swig_callbackOnPinch; + SWIG_Callback36_t swig_callbackOnPan; + SWIG_Callback37_t swig_callbackOnTap; + SWIG_Callback38_t swig_callbackOnLongPress; + SWIG_Callback39_t swig_callbackSignalConnected; + SWIG_Callback40_t swig_callbackSignalDisconnected; + void swig_init_callbacks(); +}; + +class SwigDirector_ItemFactory : public Dali::Toolkit::ItemFactory, public Swig::Director { + +public: + SwigDirector_ItemFactory(); + virtual ~SwigDirector_ItemFactory(); + virtual unsigned int GetNumberOfItems(); + virtual Dali::Actor NewItem(unsigned int itemId); + virtual void ItemReleased(unsigned int itemId, Dali::Actor actor); + virtual Dali::Toolkit::ItemFactory::Extension *GetExtension(); + + typedef unsigned int (SWIGSTDCALL* SWIG_Callback0_t)(); + typedef void * (SWIGSTDCALL* SWIG_Callback1_t)(unsigned int); + typedef void (SWIGSTDCALL* SWIG_Callback2_t)(unsigned int, void *); + void swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased); + +private: + SWIG_Callback0_t swig_callbackGetNumberOfItems; + SWIG_Callback1_t swig_callbackNewItem; + SWIG_Callback2_t swig_callbackItemReleased; + void swig_init_callbacks(); +}; + +class SwigDirector_CustomAlgorithmInterface : public Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface, public Swig::Director { + +public: + SwigDirector_CustomAlgorithmInterface(); + virtual ~SwigDirector_CustomAlgorithmInterface(); + virtual Dali::Actor GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction, const std::string& deviceName = ""); + + typedef void * (SWIGSTDCALL* SWIG_Callback0_t)(void *, void *, int, const char*); + void swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor); + +private: + SWIG_Callback0_t swig_callbackGetNextFocusableActor; + void swig_init_callbacks(); +}; + +class SwigDirector_FrameCallbackInterface : public Dali::FrameCallbackInterface, public Swig::Director { +public: + SwigDirector_FrameCallbackInterface(); + virtual ~SwigDirector_FrameCallbackInterface(); + virtual bool Update( Dali::UpdateProxy& updateProxy, float elapsedSeconds ); + + typedef void (SWIGSTDCALL* SWIG_Callback0_t)( void* updateProxy, float elapsedSeconds ); + void swig_connect_director( SWIG_Callback0_t callbackUpdate ); + + +private: + SWIG_Callback0_t swig_callbackOnUpdate; +}; + +#endif diff --git a/dali-csharp-binder/common/nui-view-accessible.cpp b/dali-csharp-binder/common/nui-view-accessible.cpp new file mode 100644 index 00000000..be9a11f3 --- /dev/null +++ b/dali-csharp-binder/common/nui-view-accessible.cpp @@ -0,0 +1,723 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// CLASS HEADER +#include "nui-view-accessible.h" + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +using namespace Dali; +using namespace Dali::Toolkit; + +using Interface = Accessibility::AtspiInterface; +using IntPairType = NUIViewAccessible::IntPairType; +using IntVectorType = NUIViewAccessible::IntVectorType; + +namespace +{ +void GetAttributesCallback(const char* key, const char* value, Accessibility::Attributes* attributes) +{ + attributes->insert_or_assign(key, value); +} + +void GetSelectedRowsColumnsCallback(int index, IntVectorType* vector) +{ + vector->push_back(index); +} + +using GetAttributesCallbackType = decltype(&GetAttributesCallback); +using GetSelectedRowsColumnsCallbackType = decltype(&GetSelectedRowsColumnsCallback); + +} // unnamed namespace + +// Keep this structure layout binary compatible with the respective C# structure! +struct NUIViewAccessible::AccessibilityDelegate +{ + AccessibilityDelegate() = delete; + + // clang-format off + char* (*getName) (RefObject*); // 1 + char* (*getDescription) (RefObject*); // 2 + bool (*doAction) (RefObject*, const char*); // 3 + std::uint64_t (*calculateStates) (RefObject*, std::uint64_t); // 4 + int (*getActionCount) (RefObject*); // 5 + char* (*getActionName) (RefObject*, int); // 6 + std::uint32_t (*getInterfaces) (RefObject*); // 7 + double (*getMinimum) (RefObject*); // 8 + double (*getCurrent) (RefObject*); // 9 + double (*getMaximum) (RefObject*); // 10 + bool (*setCurrent) (RefObject*, double); // 11 + double (*getMinimumIncrement) (RefObject*); // 12 + bool (*isScrollable) (RefObject*); // 13 + char* (*getText) (RefObject*, int, int); // 14 + int (*getCharacterCount) (RefObject*); // 15 + int (*getCursorOffset) (RefObject*); // 16 + bool (*setCursorOffset) (RefObject*, int); // 17 + Accessibility::Range* (*getTextAtOffset) (RefObject*, int, int); // 18 + Accessibility::Range* (*getRangeOfSelection) (RefObject*, int); // 19 + bool (*removeSelection) (RefObject*, int); // 20 + bool (*setRangeOfSelection) (RefObject*, int, int, int); // 21 + bool (*copyText) (RefObject*, int, int); // 22 + bool (*cutText) (RefObject*, int, int); // 23 + bool (*insertText) (RefObject*, int, const char*); // 24 + bool (*setTextContents) (RefObject*, const char*); // 25 + bool (*deleteText) (RefObject*, int, int); // 26 + bool (*scrollToChild) (RefObject*, Actor*); // 27 + int (*getSelectedChildrenCount)(RefObject*); // 28 + Actor* (*getSelectedChild) (RefObject*, int); // 29 + bool (*selectChild) (RefObject*, int); // 30 + bool (*deselectSelectedChild) (RefObject*, int); // 31 + bool (*isChildSelected) (RefObject*, int); // 32 + bool (*selectAll) (RefObject*); // 33 + bool (*clearSelection) (RefObject*); // 34 + bool (*deselectChild) (RefObject*, int); // 35 + Rect* (*getRangeExtents) (RefObject*, int, int, int); // 36 + void (*getAttributes) (RefObject*, GetAttributesCallbackType, Accessibility::Attributes*); // 37 + char* (*getValueText) (RefObject*); // 38 + int (*getRowCount) (RefObject*); // 39 + int (*getColumnCount) (RefObject*); // 40 + int (*getSelectedRowCount) (RefObject*); // 41 + int (*getSelectedColumnCount) (RefObject*); // 42 + Actor* (*getCaption) (RefObject*); // 43 + Actor* (*getSummary) (RefObject*); // 44 + Actor* (*getCell) (RefObject*, int, int); // 45 + std::uint64_t (*getChildIndex) (RefObject*, int, int); // 46 + IntPairType* (*getPositionByChildIndex) (RefObject*, std::uint64_t); // 47 + char* (*getRowDescription) (RefObject*, int); // 48 + char* (*getColumnDescription) (RefObject*, int); // 49 + Actor* (*getRowHeader) (RefObject*, int); // 50 + Actor* (*getColumnHeader) (RefObject*, int); // 51 + void (*getSelectedRows) (RefObject*, GetSelectedRowsColumnsCallbackType, IntVectorType*); // 52 + void (*getSelectedColumns) (RefObject*, GetSelectedRowsColumnsCallbackType, IntVectorType*); // 53 + bool (*isRowSelected) (RefObject*, int); // 54 + bool (*isColumnSelected) (RefObject*, int); // 55 + bool (*isCellSelected) (RefObject*, int, int); // 56 + bool (*addRowSelection) (RefObject*, int); // 57 + bool (*addColumnSelection) (RefObject*, int); // 58 + bool (*removeRowSelection) (RefObject*, int); // 59 + bool (*removeColumnSelection) (RefObject*, int); // 60 + Actor* (*getTable) (RefObject*); // 61 + IntPairType* (*getCellPosition) (RefObject*); // 62 + int (*getCellRowSpan) (RefObject*); // 63 + int (*getCellColumnSpan) (RefObject*); // 64 + // clang-format on +}; + +NUIViewAccessible::NUIViewAccessible(Actor actor) +: ControlAccessible(actor) +{ + DALI_ASSERT_DEBUG(mTable); +} + +void NUIViewAccessible::SetAccessibilityDelegate(const AccessibilityDelegate* accessibilityDelegate) +{ + if(mTable) + { + DALI_LOG_ERROR("Overwriting global AccessibilityDelegate"); + } + + mTable = accessibilityDelegate; +} + +std::string NUIViewAccessible::StealString(char* str) +{ + std::string ret{}; + + if(str) + { + ret = {str}; + free(str); + } + + return ret; +} + +template +T NUIViewAccessible::StealObject(T* obj) +{ + T ret{}; + + if(obj) + { + ret = std::move(*obj); + delete obj; + } + + return ret; +} + +template +R NUIViewAccessible::CallMethod(R (*method)(RefObject*, Args...), Args... args) const +{ + DALI_ASSERT_DEBUG(method); + DALI_ASSERT_ALWAYS(GetInterfaces()[I]); + + return method(Self().GetObjectPtr(), args...); +} + +// +// Standard interfaces (Accessible, Action, Component) +// + +std::string NUIViewAccessible::GetNameRaw() const +{ + char* name = CallMethod(mTable->getName); + + return StealString(name); +} + +std::string NUIViewAccessible::GetDescriptionRaw() const +{ + char* description = CallMethod(mTable->getDescription); + + return StealString(description); +} + +bool NUIViewAccessible::GrabHighlight() +{ + bool ret = ControlAccessible::GrabHighlight(); + + if(ret) + { + // Note: Currently (2021-03-26), size negotiation between the default highlight frame + // and NUI Components is known to be broken (and possibly in other cases, too). Please + // remove this for GrabHighlight() when it is fixed. + auto size = Self().GetProperty(Actor::Property::SIZE); + mCurrentHighlightActor.GetHandle().SetProperty(Actor::Property::SIZE, size); + } + + return ret; +} + +std::string NUIViewAccessible::GetActionName(std::size_t index) const +{ + char* name = CallMethod(mTable->getActionName, static_cast(index)); + + return StealString(name); +} + +std::size_t NUIViewAccessible::GetActionCount() const +{ + int count = CallMethod(mTable->getActionCount); + + return static_cast(count); +} + +bool NUIViewAccessible::DoAction(std::size_t index) +{ + return DoAction(GetActionName(index)); +} + +bool NUIViewAccessible::DoAction(const std::string& name) +{ + return CallMethod(mTable->doAction, name.c_str()); +} + +Accessibility::States NUIViewAccessible::CalculateStates() +{ + std::uint64_t states = ControlAccessible::CalculateStates().GetRawData64(); + + states = CallMethod(mTable->calculateStates, states); + + return Accessibility::States{states}; +} + +Accessibility::Attributes NUIViewAccessible::GetAttributes() const +{ + auto attributes = ControlAccessible::GetAttributes(); + + CallMethod(mTable->getAttributes, &GetAttributesCallback, &attributes); + + return attributes; +} + +Property::Index NUIViewAccessible::GetNamePropertyIndex() +{ + return Property::INVALID_INDEX; +} + +Property::Index NUIViewAccessible::GetDescriptionPropertyIndex() +{ + return Property::INVALID_INDEX; +} + +bool NUIViewAccessible::IsScrollable() const +{ + return CallMethod(mTable->isScrollable); +} + +bool NUIViewAccessible::ScrollToChild(Actor child) +{ + return CallMethod(mTable->scrollToChild, new Actor(child)); +} + +Accessibility::AtspiInterfaces NUIViewAccessible::DoGetInterfaces() const +{ + using Interfaces = Accessibility::AtspiInterfaces; + + Interfaces baseInterfaces; + Interfaces extraInterfaces; + + // These are always implemented + baseInterfaces[Interface::ACCESSIBLE] = true; + baseInterfaces[Interface::ACTION] = true; + baseInterfaces[Interface::COLLECTION] = true; + baseInterfaces[Interface::COMPONENT] = true; + + // We cannot use CallMethod() here as that would cause recursion. + // Note that the result will be cached and subsequent calls to GetInterfaces() + // will not involve calling this virtual method or jumping into C# code. + extraInterfaces = Interfaces{mTable->getInterfaces(Self().GetObjectPtr())}; + + return baseInterfaces | extraInterfaces; +} + +// +// Value interface +// + +double NUIViewAccessible::GetMinimum() const +{ + return CallMethod(mTable->getMinimum); +} + +double NUIViewAccessible::GetCurrent() const +{ + return CallMethod(mTable->getCurrent); +} + +std::string NUIViewAccessible::GetValueText() const +{ + char *text = CallMethod(mTable->getValueText); + + return StealString(text); +} + +double NUIViewAccessible::GetMaximum() const +{ + return CallMethod(mTable->getMaximum); +} + +bool NUIViewAccessible::SetCurrent(double value) +{ + return CallMethod(mTable->setCurrent, value); +} + +double NUIViewAccessible::GetMinimumIncrement() const +{ + return CallMethod(mTable->getMinimumIncrement); +} + +// +// Text interface +// + +std::string NUIViewAccessible::GetText(std::size_t startOffset, std::size_t endOffset) const +{ + char* text = CallMethod(mTable->getText, static_cast(startOffset), static_cast(endOffset)); + + return StealString(text); +} + +std::size_t NUIViewAccessible::GetCharacterCount() const +{ + int count = CallMethod(mTable->getCharacterCount); + + return static_cast(count); +} + +std::size_t NUIViewAccessible::GetCursorOffset() const +{ + int offset = CallMethod(mTable->getCursorOffset); + + return static_cast(offset); +} + +bool NUIViewAccessible::SetCursorOffset(std::size_t offset) +{ + return CallMethod(mTable->setCursorOffset, static_cast(offset)); +} + +Accessibility::Range NUIViewAccessible::GetTextAtOffset(std::size_t offset, Accessibility::TextBoundary boundary) const +{ + Accessibility::Range* range = CallMethod(mTable->getTextAtOffset, static_cast(offset), static_cast(boundary)); + + return StealObject(range); +} + +Accessibility::Range NUIViewAccessible::GetRangeOfSelection(std::size_t selectionIndex) const +{ + Accessibility::Range* range = CallMethod(mTable->getRangeOfSelection, static_cast(selectionIndex)); + + return StealObject(range); +} + +bool NUIViewAccessible::RemoveSelection(std::size_t selectionIndex) +{ + return CallMethod(mTable->removeSelection, static_cast(selectionIndex)); +} + +bool NUIViewAccessible::SetRangeOfSelection(std::size_t selectionIndex, std::size_t startOffset, std::size_t endOffset) +{ + return CallMethod(mTable->setRangeOfSelection, static_cast(selectionIndex), static_cast(startOffset), static_cast(endOffset)); +} + +Rect<> NUIViewAccessible::GetRangeExtents(std::size_t startOffset, std::size_t endOffset, Accessibility::CoordinateType type) +{ + auto rectPtr = CallMethod(mTable->getRangeExtents, static_cast(startOffset), static_cast(endOffset), static_cast(type)); + Rect rect = StealObject(rectPtr); + + return {(float)rect.x, (float)rect.y, (float)rect.width, (float)rect.height}; +} + +// +// EditableText interface +// + +bool NUIViewAccessible::CopyText(std::size_t startPosition, std::size_t endPosition) +{ + return CallMethod(mTable->copyText, static_cast(startPosition), static_cast(endPosition)); +} + +bool NUIViewAccessible::CutText(std::size_t startPosition, std::size_t endPosition) +{ + return CallMethod(mTable->cutText, static_cast(startPosition), static_cast(endPosition)); +} + +bool NUIViewAccessible::InsertText(std::size_t startPosition, std::string text) +{ + return CallMethod(mTable->insertText, static_cast(startPosition), text.c_str()); +} + +bool NUIViewAccessible::SetTextContents(std::string newContents) +{ + return CallMethod(mTable->setTextContents, newContents.c_str()); +} + +bool NUIViewAccessible::DeleteText(std::size_t startPosition, std::size_t endPosition) +{ + return CallMethod(mTable->deleteText, static_cast(startPosition), static_cast(endPosition)); +} + +// +// Selection interface +// + +int NUIViewAccessible::GetSelectedChildrenCount() const +{ + return CallMethod(mTable->getSelectedChildrenCount); +} + +Accessibility::Accessible* NUIViewAccessible::GetSelectedChild(int selectedChildIndex) +{ + Actor* actor = CallMethod(mTable->getSelectedChild, selectedChildIndex); + + return actor ? Accessibility::Accessible::Get(*actor) : nullptr; +} + +bool NUIViewAccessible::SelectChild(int childIndex) +{ + return CallMethod(mTable->selectChild, childIndex); +} + +bool NUIViewAccessible::DeselectSelectedChild(int selectedChildIndex) +{ + return CallMethod(mTable->deselectSelectedChild, selectedChildIndex); +} + +bool NUIViewAccessible::IsChildSelected(int childIndex) const +{ + return CallMethod(mTable->isChildSelected, childIndex); +} + +bool NUIViewAccessible::SelectAll() +{ + return CallMethod(mTable->selectAll); +} + +bool NUIViewAccessible::ClearSelection() +{ + return CallMethod(mTable->clearSelection); +} + +bool NUIViewAccessible::DeselectChild(int childIndex) +{ + return CallMethod(mTable->deselectChild, childIndex); +} + +// +// Table interface +// + +int NUIViewAccessible::GetRowCount() const +{ + return CallMethod(mTable->getRowCount); +} + +int NUIViewAccessible::GetColumnCount() const +{ + return CallMethod(mTable->getColumnCount); +} + +int NUIViewAccessible::GetSelectedRowCount() const +{ + return CallMethod(mTable->getSelectedRowCount); +} + +int NUIViewAccessible::GetSelectedColumnCount() const +{ + return CallMethod(mTable->getSelectedColumnCount); +} + +Accessibility::Accessible* NUIViewAccessible::GetCaption() const +{ + Actor* caption = CallMethod(mTable->getCaption); + + return caption ? Accessibility::Accessible::Get(*caption) : nullptr; +} + +Accessibility::Accessible* NUIViewAccessible::GetSummary() const +{ + Actor* summary = CallMethod(mTable->getSummary); + + return summary ? Accessibility::Accessible::Get(*summary) : nullptr; +} + +Accessibility::TableCell* NUIViewAccessible::GetCell(int row, int column) const +{ + Actor* cell = CallMethod(mTable->getCell, row, column); + + return cell ? Accessibility::TableCell::DownCast(Accessibility::Accessible::Get(*cell)) : nullptr; +} + +std::size_t NUIViewAccessible::GetChildIndex(int row, int column) const +{ + std::uint64_t index = CallMethod(mTable->getChildIndex, row, column); + + return static_cast(index); +} + +IntPairType NUIViewAccessible::GetPositionByChildIndex(std::size_t childIndex) const +{ + IntPairType* position = CallMethod(mTable->getPositionByChildIndex, static_cast(childIndex)); + + return StealObject(position); +} + +int NUIViewAccessible::GetRowByChildIndex(std::size_t childIndex) const +{ + return GetPositionByChildIndex(childIndex).first; +} + +int NUIViewAccessible::GetColumnByChildIndex(std::size_t childIndex) const +{ + return GetPositionByChildIndex(childIndex).second; +} + +std::string NUIViewAccessible::GetRowDescription(int row) const +{ + char* description = CallMethod(mTable->getRowDescription, row); + + return StealString(description); +} + +std::string NUIViewAccessible::GetColumnDescription(int column) const +{ + char* description = CallMethod(mTable->getColumnDescription, column); + + return StealString(description); +} + +int NUIViewAccessible::GetRowSpan(int row, int column) const +{ + Accessibility::TableCell* cell = GetCell(row, column); + + return cell ? cell->GetCellRowSpan() : -1; +} + +int NUIViewAccessible::GetColumnSpan(int row, int column) const +{ + Accessibility::TableCell* cell = GetCell(row, column); + + return cell ? cell->GetCellColumnSpan() : -1; +} + +Accessibility::Accessible* NUIViewAccessible::GetRowHeader(int row) const +{ + Actor* header = CallMethod(mTable->getRowHeader, row); + + return header ? Accessibility::Accessible::Get(*header) : nullptr; +} + +Accessibility::Accessible* NUIViewAccessible::GetColumnHeader(int column) const +{ + Actor* header = CallMethod(mTable->getColumnHeader, column); + + return header ? Accessibility::Accessible::Get(*header) : nullptr; +} + +IntVectorType NUIViewAccessible::GetSelectedRows() const +{ + IntVectorType result; + + CallMethod(mTable->getSelectedRows, &GetSelectedRowsColumnsCallback, &result); + + return result; +} + +IntVectorType NUIViewAccessible::GetSelectedColumns() const +{ + IntVectorType result; + + CallMethod(mTable->getSelectedColumns, &GetSelectedRowsColumnsCallback, &result); + + return result; +} + +bool NUIViewAccessible::IsRowSelected(int row) const +{ + return CallMethod(mTable->isRowSelected, row); +} + +bool NUIViewAccessible::IsColumnSelected(int column) const +{ + return CallMethod(mTable->isColumnSelected, column); +} + +bool NUIViewAccessible::IsCellSelected(int row, int column) const +{ + return CallMethod(mTable->isCellSelected, row, column); +} + +bool NUIViewAccessible::AddRowSelection(int row) +{ + return CallMethod(mTable->addRowSelection, row); +} + +bool NUIViewAccessible::AddColumnSelection(int column) +{ + return CallMethod(mTable->addColumnSelection, column); +} + +bool NUIViewAccessible::RemoveRowSelection(int row) +{ + return CallMethod(mTable->removeRowSelection, row); +} + +bool NUIViewAccessible::RemoveColumnSelection(int column) +{ + return CallMethod(mTable->removeColumnSelection, column); +} + +Accessibility::Table::RowColumnSpanType NUIViewAccessible::GetRowColumnSpan(std::size_t childIndex) const +{ + Accessibility::Table::RowColumnSpanType span{.success = false}; + + std::tie(span.row, span.column) = GetPositionByChildIndex(childIndex); + Accessibility::TableCell* cell = GetCell(span.row, span.column); + if (!cell) + { + return span; + } + + span.success = true; + span.isSelected = IsCellSelected(span.row, span.column); + span.rowSpan = cell->GetCellRowSpan(); + span.columnSpan = cell->GetCellColumnSpan(); + + return span; +} + +// +// TableCell interface +// + +Accessibility::Table* NUIViewAccessible::GetTable() const +{ + Actor* table = CallMethod(mTable->getTable); + + return table ? Accessibility::Table::DownCast(Accessibility::Accessible::Get(*table)) : nullptr; +} + +IntPairType NUIViewAccessible::GetCellPosition() const +{ + IntPairType* position = CallMethod(mTable->getCellPosition); + + return StealObject(position); +} + +int NUIViewAccessible::GetCellRowSpan() const +{ + return CallMethod(mTable->getCellRowSpan); +} + +int NUIViewAccessible::GetCellColumnSpan() const +{ + return CallMethod(mTable->getCellColumnSpan); +} + +Accessibility::TableCell::RowColumnSpanType NUIViewAccessible::GetCellRowColumnSpan() const +{ + Accessibility::TableCell::RowColumnSpanType span{}; + + std::tie(span.row, span.column) = GetCellPosition(); + span.rowSpan = GetCellRowSpan(); + span.columnSpan = GetCellColumnSpan(); + + return span; +} + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Accessibility_DuplicateString(const char* arg) +{ + return strdup(arg); +} + +SWIGEXPORT IntPairType* SWIGSTDCALL CSharp_Dali_Accessibility_MakeIntPair(int first, int second) +{ + return new IntPairType(first, second); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_SetAccessibilityDelegate(const void* arg1_accessibilityDelegate, uint32_t arg2_accessibilityDelegateSize) +{ + GUARD_ON_NULL_RET(arg1_accessibilityDelegate); + + const auto* accessibilityDelegate = static_cast(arg1_accessibilityDelegate); + auto accessibilityDelegateSize = static_cast(arg2_accessibilityDelegateSize); + + try_catch(([&]() { + if(accessibilityDelegateSize != sizeof(*accessibilityDelegate)) + { + DALI_LOG_ERROR("SetAccessibilityDelegate error: Marshal.SizeOf()[%zu] != sizeof(AccessibilityDelegate)[%zu]\n", accessibilityDelegateSize, sizeof(*accessibilityDelegate)); + throw std::runtime_error("SetAccessibilityDelegate error: Marshal.SizeOf() != sizeof(AccessibilityDelegate)"); + } + + NUIViewAccessible::SetAccessibilityDelegate(accessibilityDelegate); + Accessibility::Bridge::GetCurrentBridge()->SetToolkitName("nui(dali)"); + })); +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/dali-csharp-binder/common/nui-view-accessible.h b/dali-csharp-binder/common/nui-view-accessible.h new file mode 100644 index 00000000..0582a531 --- /dev/null +++ b/dali-csharp-binder/common/nui-view-accessible.h @@ -0,0 +1,252 @@ +/* + * Copyright (c) 2023 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. + * + */ + +#ifndef NUI_VIEW_ACCESSIBLE_H +#define NUI_VIEW_ACCESSIBLE_H + +// EXTERNAL INCLUDES +#include +#include +#include +#include +#include +#include +#include +#include + +class NUIViewAccessible : public Dali::Toolkit::DevelControl::ControlAccessible, + public virtual Dali::Accessibility::EditableText, // includes Text + public virtual Dali::Accessibility::Selection, + public virtual Dali::Accessibility::Value, + public virtual Dali::Accessibility::Table, + public virtual Dali::Accessibility::TableCell + +{ +public: + struct AccessibilityDelegate; // Forward declaration + + using IntPairType = std::pair; + using IntVectorType = std::vector; + + NUIViewAccessible() = delete; + NUIViewAccessible(const NUIViewAccessible&) = delete; + NUIViewAccessible(NUIViewAccessible&&) = delete; + + NUIViewAccessible& operator=(const NUIViewAccessible&) = delete; + NUIViewAccessible& operator=(NUIViewAccessible&&) = delete; + + NUIViewAccessible(Dali::Actor actor); + + static void SetAccessibilityDelegate(const AccessibilityDelegate* accessibilityDelegate); + + // Standard interfaces (Accessible, Action, Component) + + std::string GetNameRaw() const override; + + std::string GetDescriptionRaw() const override; + + bool GrabHighlight() override; + + std::string GetActionName(std::size_t index) const override; + + std::size_t GetActionCount() const override; + + bool DoAction(std::size_t index) override; + + bool DoAction(const std::string& name) override; + + Dali::Accessibility::States CalculateStates() override; + + Dali::Accessibility::Attributes GetAttributes() const override; + + Dali::Property::Index GetNamePropertyIndex() override; + + Dali::Property::Index GetDescriptionPropertyIndex() override; + + bool IsScrollable() const override; + + bool ScrollToChild(Dali::Actor child) override; + + Dali::Accessibility::AtspiInterfaces DoGetInterfaces() const override; + + // Value interface + + double GetMinimum() const override; + + double GetCurrent() const override; + + std::string GetValueText() const override; + + double GetMaximum() const override; + + bool SetCurrent(double value) override; + + double GetMinimumIncrement() const override; + + // Text interface + + std::string GetText(std::size_t startOffset, std::size_t endOffset) const override; + + std::size_t GetCharacterCount() const override; + + std::size_t GetCursorOffset() const override; + + bool SetCursorOffset(std::size_t offset) override; + + Dali::Accessibility::Range GetTextAtOffset(std::size_t offset, Dali::Accessibility::TextBoundary boundary) const override; + + Dali::Accessibility::Range GetRangeOfSelection(std::size_t selectionIndex) const override; + + bool RemoveSelection(std::size_t selectionIndex) override; + + bool SetRangeOfSelection(std::size_t selectionIndex, std::size_t startOffset, std::size_t endOffset) override; + + Dali::Rect<> GetRangeExtents(std::size_t startOffset, std::size_t endOffset, Dali::Accessibility::CoordinateType type) override; + + // EditableText interface + + bool CopyText(std::size_t startPosition, std::size_t endPosition) override; + + bool CutText(std::size_t startPosition, std::size_t endPosition) override; + + bool InsertText(std::size_t startPosition, std::string text) override; + + bool SetTextContents(std::string newContents) override; + + bool DeleteText(std::size_t startPosition, std::size_t endPosition) override; + + // Selection interface + + int GetSelectedChildrenCount() const override; + + Dali::Accessibility::Accessible* GetSelectedChild(int selectedChildIndex) override; + + bool SelectChild(int childIndex) override; + + bool DeselectSelectedChild(int selectedChildIndex) override; + + bool IsChildSelected(int childIndex) const override; + + bool SelectAll() override; + + bool ClearSelection() override; + + bool DeselectChild(int childIndex) override; + + // Table interface + + int GetRowCount() const override; + + int GetColumnCount() const override; + + int GetSelectedRowCount() const override; + + int GetSelectedColumnCount() const override; + + Dali::Accessibility::Accessible* GetCaption() const override; + + Dali::Accessibility::Accessible* GetSummary() const override; + + Dali::Accessibility::TableCell* GetCell(int row, int column) const override; + + std::size_t GetChildIndex(int row, int column) const override; + + // Non-virtual helper. Inverse of GetChildIndex(). + IntPairType GetPositionByChildIndex(std::size_t childIndex) const; + + int GetRowByChildIndex(std::size_t childIndex) const override; + + int GetColumnByChildIndex(std::size_t childIndex) const override; + + std::string GetRowDescription(int row) const override; + + std::string GetColumnDescription(int column) const override; + + int GetRowSpan(int row, int column) const override; + + int GetColumnSpan(int row, int column) const override; + + Dali::Accessibility::Accessible* GetRowHeader(int row) const override; + + Dali::Accessibility::Accessible* GetColumnHeader(int column) const override; + + IntVectorType GetSelectedRows() const override; + + IntVectorType GetSelectedColumns() const override; + + bool IsRowSelected(int row) const override; + + bool IsColumnSelected(int column) const override; + + bool IsCellSelected(int row, int column) const override; + + bool AddRowSelection(int row) override; + + bool AddColumnSelection(int column) override; + + bool RemoveRowSelection(int row) override; + + bool RemoveColumnSelection(int column) override; + + Dali::Accessibility::Table::RowColumnSpanType GetRowColumnSpan(std::size_t childIndex) const override; + + // TableCell interface + + Dali::Accessibility::Table* GetTable() const override; + + IntPairType GetCellPosition() const override; + + int GetCellRowSpan() const override; + + int GetCellColumnSpan() const override; + + Dali::Accessibility::TableCell::RowColumnSpanType GetCellRowColumnSpan() const override; + +private: + // Points to memory managed from the C# side + static inline const AccessibilityDelegate* mTable = nullptr; + + // Frees memory allocated in C# via a call to CSharp_Dali_Accessibility_DuplicateString + static std::string StealString(char* str); + + // Frees memory allocated in C# via a call to an interop that calls 'operator new' + template + static T StealObject(T* obj); + + /** + * @brief Safely calls a virtual C# method through AccessibilityDelegate. + * + * This verifies that the specified function pointer is not null and that + * the specified interface is implemented by the target object. This is due + * to the fact that dynamic_cast can see more interfaces than this object + * is meant to represent (dynamic_cast cannot be used to examine C# objects, + * so we have to rely on a set of AtspiInterfaces returned by GetInterfaces). + * + * @tparam I The interface that the method belongs to + * @tparam R The return type of the method (deduced automatically) + * @tparam Args The parameter types of the method (deduced automatically) + * + * @param method The method (function pointer from AccessibilityDelegate) + * @param args Method arguments + * + * @return Value returned by the chosen method + */ + template + R CallMethod(R (*method)(Dali::RefObject*, Args...), Args... args) const; +}; + +#endif // NUI_VIEW_ACCESSIBLE_H diff --git a/dali-csharp-binder/common/processor-controller.cpp b/dali-csharp-binder/common/processor-controller.cpp new file mode 100644 index 00000000..d8d699b4 --- /dev/null +++ b/dali-csharp-binder/common/processor-controller.cpp @@ -0,0 +1,186 @@ +/* + * Copyright (c) 2021 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. + * + */ + +// CLASS HEADER +#include "processor-controller.h" + +// EXTERNAL INCLUDES +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +ProcessorController::ProcessorController() +: mHandler(nullptr), + mPostHandler(nullptr), + mKeepRenderingApplied(false) +{ + { + try + { + Dali::Adaptor::Get().RegisterProcessor(*this); + Dali::Adaptor::Get().RegisterProcessor(*this, true); + } + CALL_CATCH_EXCEPTION(); + } +} + +ProcessorController::~ProcessorController() +{ + { + try + { + Dali::Adaptor::Get().UnregisterProcessor(*this); + Dali::Adaptor::Get().UnregisterProcessor(*this, true); + } + CALL_CATCH_EXCEPTION(); + } +} + +void ProcessorController::Process(bool postProcessor) +{ + if(!postProcessor) + { + // We will ignore Awake events during Process running + mKeepRenderingApplied = true; + if(DALI_LIKELY(mHandler != nullptr)) + { + mHandler(); + } + } + else + { + if(DALI_LIKELY(mPostHandler != nullptr)) + { + mPostHandler(); + } + // Make awake events can be applied after PostProcess done. + mKeepRenderingApplied = false; + } +} + +void ProcessorController::SetCallback( ProcessorControllerProcessCallback callback ) +{ + mHandler = callback; +} + +void ProcessorController::SetPostCallback( ProcessorControllerProcessCallback postCallback ) +{ + mPostHandler = postCallback; +} + +void ProcessorController::RemoveCallback( ProcessorControllerProcessCallback callback ) +{ + mHandler = nullptr; +} +void ProcessorController::RemovePostCallback( ProcessorControllerProcessCallback postCallback ) +{ + mPostHandler = nullptr; +} + +void ProcessorController::Awake() +{ + if(DALI_UNLIKELY(!mKeepRenderingApplied)) + { + if(DALI_LIKELY(Dali::Stage::IsInstalled())) + { + auto stage = Dali::Stage::GetCurrent(); + stage.KeepRendering(0.0f); + mKeepRenderingApplied = true; + } + } +} + +// ProcessorController Bindings +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProcessorController() { + + ProcessorController *result = 0 ; + + { + try { + result = (ProcessorController *)new ProcessorController(); + } CALL_CATCH_EXCEPTION(0); + } + + return (void *)result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProcessorController(void * jarg1) { + + ProcessorController * arg1 = (ProcessorController *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProcessorController_SetCallback( void* jarg1, ProcessorController::ProcessorControllerProcessCallback callback ) +{ + ProcessorController* processorController = (ProcessorController *) jarg1; + + if( processorController ) + { + processorController->SetCallback( callback ); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProcessorController_SetPostCallback( void* jarg1, ProcessorController::ProcessorControllerProcessCallback callback ) +{ + ProcessorController* processorController = (ProcessorController *) jarg1; + + if( processorController ) + { + processorController->SetPostCallback( callback ); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProcessorController_RemoveCallback( void* jarg1, ProcessorController::ProcessorControllerProcessCallback callback ) +{ + ProcessorController* processorController = (ProcessorController *) jarg1; + + if( processorController ) + { + processorController->RemoveCallback( callback ); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProcessorController_RemovePostCallback( void* jarg1, ProcessorController::ProcessorControllerProcessCallback callback ) +{ + ProcessorController* processorController = (ProcessorController *) jarg1; + + if( processorController ) + { + processorController->RemovePostCallback( callback ); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProcessorController_Awake( void* jarg1 ) +{ + ProcessorController* processorController = (ProcessorController *) jarg1; + + if( processorController ) + { + processorController->Awake(); + } +} + +#ifdef __cplusplus +} +#endif \ No newline at end of file diff --git a/dali-csharp-binder/common/processor-controller.h b/dali-csharp-binder/common/processor-controller.h new file mode 100644 index 00000000..25ab9946 --- /dev/null +++ b/dali-csharp-binder/common/processor-controller.h @@ -0,0 +1,94 @@ +#ifndef CSHARP_PROCESSOR_CONTROLLER_H +#define CSHARP_PROCESSOR_CONTROLLER_H + +/* + * Copyright (c) 2021 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include "common.h" + +/** + * @brief Implements a Integration::Processor interface so can be registered with dali-core as + * a Processor. Enables the setting of a callback so dali-core can execute this callback when + * Process() is run. + */ +class ProcessorController : public Dali::Integration::Processor +{ +public: + + // Function pointer matching delegate in C# ProcessorController + using ProcessorControllerProcessCallback = void (SWIGSTDCALL*)(); + +public: + /** + * @brief Constructor - creates a ProcessorController and registers it with dali-core. + * + */ + ProcessorController(); + + /** + * @brief Destructor - Unregisters itself from dali-core. + */ + ~ProcessorController(); + + /** + * @copydoc Dali::Integration::Processor::Process() + */ + void Process(bool postProcessor) override; + + /** + * @brief Set the callback to be executed when dali-core calls the overriden Process() api. + * @param[in] callback, function to be called + */ + void SetCallback( ProcessorControllerProcessCallback callback ); + + /** + * @brief Set the postcallback to be executed when dali-core calls the overriden Process(true) api. + * @param[in] postCallback, function to be called + */ + void SetPostCallback( ProcessorControllerProcessCallback postCallback ); + + /** + * @brief Remove callback on this ProcessorController. + * The removed callback will not be called anymore. + * @param[in] callback, function will be removed + */ + void RemoveCallback( ProcessorControllerProcessCallback callback ); + + /** + * @brief Remove postcallback on this ProcessorController. + * The removed callback will not be called anymore. + * @param[in] postCallback, function will be removed + */ + void RemovePostCallback( ProcessorControllerProcessCallback postCallback ); + + /** + * @brief Awake update thread so dali-core calls the overriden Process() api. + */ + void Awake(); + +private: + + ProcessorControllerProcessCallback mHandler; ///< PreProcessHandler before Relayout + ProcessorControllerProcessCallback mPostHandler; ///< PostProcessHandler after Relayout + bool mKeepRenderingApplied; ///< True if we call Stage::KeepRendering(0.0f). It need to avoid duplicated keep rendering call +}; + +#endif // CSHARP_PROCESSOR_CONTROLLER_H \ No newline at end of file diff --git a/dali-csharp-binder/common/signal-wrap.cpp b/dali-csharp-binder/common/signal-wrap.cpp new file mode 100644 index 00000000..dde34e1c --- /dev/null +++ b/dali-csharp-binder/common/signal-wrap.cpp @@ -0,0 +1,203 @@ +/* + * Copyright (c) 2021 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. + * + */ + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Implementation Signal is used in signals: + * AccessibilityGetName + * AccessibilityGetDescription + */ + +using StringToVoidFunc = void (*)(std::string &); +using StringToVoidSignal = Dali::Signal; + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Signal_StringToVoid_Empty(void *arg1) { + bool result = false; + GUARD_ON_NULL_RET0(arg1); + try_catch(([&]() { + auto object = (StringToVoidSignal*)arg1; + result = object->Empty(); + })); + return result; +} + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Signal_StringToVoid_GetConnectionCount(void *arg1) { + std::size_t result = 0; + GUARD_ON_NULL_RET0(arg1); + try_catch(([&]() { + auto object = (StringToVoidSignal*)arg1; + result = object->GetConnectionCount(); + })); + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Signal_StringToVoid_Connect(void *arg1, void *arg2) { + GUARD_ON_NULL_RET(arg1); + GUARD_ON_NULL_RET(arg2); + try_catch(([&]() { + auto object = (StringToVoidSignal*)arg1; + auto func = (StringToVoidFunc)arg2; + object->Connect(func); + })); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Signal_StringToVoid_Disconnect(void *arg1, void *arg2) { + GUARD_ON_NULL_RET(arg1); + GUARD_ON_NULL_RET(arg2); + try_catch(([&] () { + auto object = (StringToVoidSignal*)arg1; + auto func = (StringToVoidFunc)arg2; + object->Disconnect(func); + })); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Signal_StringToVoid_new() { + try_catch(([&]() { + return new StringToVoidSignal(); + })); + return nullptr; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Signal_StringToVoid_delete(void *arg1) { + GUARD_ON_NULL_RET(arg1); + try_catch(([&]() { + auto object = (StringToVoidSignal*)arg1; + delete object; + })); +} + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Signal_StringToVoid_GetResult(void *arg1) { + GUARD_ON_NULL_RET0(arg1); + std::string *data = (std::string*)arg1; + return SWIG_csharp_string_callback(data->c_str()); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Signal_StringToVoid_SetResult(void *arg1, char *arg2) { + GUARD_ON_NULL_RET(arg1); + GUARD_ON_NULL_RET(arg2); + try_catch(([&]() { + auto result = (std::string*)arg1; + (*result) = arg2; + })); +} + +/* + * Implementation Signal &)> is used in signals: + * AccessibilityDoGestureSignalType + */ + +using GesturePair = std::pair; +using GesturePairFunc = void (*)(GesturePair &); +using GesturePairSignal = Dali::Signal; + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_Empty(void *arg1) { + bool result = false; + GUARD_ON_NULL_RET0(arg1); + try_catch(([&]() { + auto object = (GesturePairSignal*)arg1; + result = object->Empty(); + })); + return result; +} + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_GetConnectionCount(void *arg1) { + std::size_t result = 0; + GUARD_ON_NULL_RET0(arg1); + try_catch(([&]() { + auto object = (GesturePairSignal*)arg1; + result = object->GetConnectionCount(); + })); + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_Connect(void *arg1, void *arg2) { + GUARD_ON_NULL_RET(arg1); + GUARD_ON_NULL_RET(arg2); + try_catch(([&]() { + auto object = (GesturePairSignal*)arg1; + auto func = (GesturePairFunc)arg2; + object->Connect( func ); + })); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_Disconnect(void *arg1, void *arg2) { + GUARD_ON_NULL_RET(arg1); + GUARD_ON_NULL_RET(arg2); + try_catch(([&]() { + auto object = (GesturePairSignal*)arg1; + auto func = (GesturePairFunc)arg2; + object->Disconnect(func); + })); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_Emit(void *arg1, void *arg2) { + GUARD_ON_NULL_RET(arg1); + GUARD_ON_NULL_RET(arg2); + try_catch(([&]() { + auto object = (GesturePairSignal*)arg1; + auto gesturePair = (GesturePair*)arg2; + object->Emit(*gesturePair); + })); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_new() { + try_catch(([&]() { + return new GesturePairSignal(); + })); + return nullptr; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_delete(void *arg1) { + GUARD_ON_NULL_RET(arg1); + try_catch(([&]() { + auto object = (GesturePairSignal*)arg1; + delete object; + })); +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_GetSizeOfGestureInfo(void) { + return sizeof(Dali::Accessibility::GestureInfo); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_GetResult(void *arg1) { + bool result = false; + GUARD_ON_NULL_RET0(arg1); + try_catch(([&]() { + auto gesturePair = (GesturePair*)arg1; + result = (bool)gesturePair->second; + })); + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_SetResult(void *arg1, bool arg2) { + bool result = arg2; + GUARD_ON_NULL_RET(arg1); + try_catch(([&]() { + auto gesturePair = (GesturePair*)arg1; + gesturePair->second = result; + })); +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/common/slim-custom-view-impl.cpp b/dali-csharp-binder/common/slim-custom-view-impl.cpp new file mode 100644 index 00000000..a2ecdce2 --- /dev/null +++ b/dali-csharp-binder/common/slim-custom-view-impl.cpp @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// CLASS HEADER +#include "slim-custom-view-impl.h" + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include "nui-view-accessible.h" + +SlimCustomViewImpl::SlimCustomViewImpl(ControlBehaviour behaviourFlags) : Control(behaviourFlags) +{ +} + +Dali::Toolkit::Control SlimCustomViewImpl::New(ControlBehaviour additionalBehaviour) +{ + // Create the implementation, temporarily owned on stack + Dali::IntrusivePtr controlImpl = new SlimCustomViewImpl(Control::ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT | additionalBehaviour)); + + // Pass ownership to handle + Dali::Toolkit::Control handle(*controlImpl); + + // Second-phase init of the implementation + // This can only be done after the CustomActor connection has been made... + controlImpl->Initialize(); + + // Impersonate Control by adopting its TypeInfo. Without this, many things don't work. + Dali::TypeInfo typeInfo = Dali::TypeRegistry::Get().GetTypeInfo(typeid(Control)); + if(typeInfo) + { + Dali::DevelHandle::SetTypeInfo(handle, typeInfo); + } + + return handle; +} + +Dali::Toolkit::DevelControl::ControlAccessible* SlimCustomViewImpl::CreateAccessibleObject() +{ + return new NUIViewAccessible(Self()); +} diff --git a/dali-csharp-binder/common/slim-custom-view-impl.h b/dali-csharp-binder/common/slim-custom-view-impl.h new file mode 100644 index 00000000..a2cb8e6a --- /dev/null +++ b/dali-csharp-binder/common/slim-custom-view-impl.h @@ -0,0 +1,45 @@ +#ifndef CSHARP_SLIM_CUSTOM_VIEW_IMPL_H +#define CSHARP_SLIM_CUSTOM_VIEW_IMPL_H + +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include "common.h" + +// SlimCustomViewImpl behaves almost identically to Toolkit::Internal::Control, +// but is associated with a NUIViewAccessible, therefore opening the possibility +// of providing Accessibility support in C#. +class SlimCustomViewImpl : public Dali::Toolkit::Internal::Control +{ + using Dali::Toolkit::Internal::Control::ControlBehaviour; + + SlimCustomViewImpl(ControlBehaviour behaviourFlags); + +public: + static Dali::Toolkit::Control New(ControlBehaviour additionalBehaviour); + +protected: + Dali::Toolkit::DevelControl::ControlAccessible* CreateAccessibleObject() override; +}; + +#endif // CSHARP_SLIM_CUSTOM_VIEW_IMPL_H diff --git a/dali-csharp-binder/common/stdafx.h b/dali-csharp-binder/common/stdafx.h new file mode 100644 index 00000000..d42a852c --- /dev/null +++ b/dali-csharp-binder/common/stdafx.h @@ -0,0 +1,30 @@ +/* + * 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. + * + */ + +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#pragma once + +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers + +// Windows Header Files: +#include + +// TODO: reference additional headers your program requires here diff --git a/dali-csharp-binder/common/tizen-dependency-wrap.cpp b/dali-csharp-binder/common/tizen-dependency-wrap.cpp new file mode 100644 index 00000000..06eb44c8 --- /dev/null +++ b/dali-csharp-binder/common/tizen-dependency-wrap.cpp @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2020 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include "common.h" + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Texture_TbmSurface(tbm_surface_h tbm_surface) { + Dali::NativeImageSourcePtr mNativeImageSrc; + Dali::Texture mNativeTexture; + void * jresult ; + + if (!tbm_surface) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "tbm surface is null", 0); + return 0; + } + + try { + Dali::Any source(tbm_surface); + mNativeImageSrc = Dali::NativeImageSource::New(source); + mNativeTexture = Dali::Texture::New( *mNativeImageSrc ); + } CALL_CATCH_EXCEPTION(0); + + jresult = new Dali::Texture((const Dali::Texture &)mNativeTexture); + return (void*)jresult; +} + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/common/version-check.cpp b/dali-csharp-binder/common/version-check.cpp new file mode 100755 index 00000000..e75f9fcf --- /dev/null +++ b/dali-csharp-binder/common/version-check.cpp @@ -0,0 +1,141 @@ +/* + * Copyright (c) 2018 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. + * + */ + +// INTERNAL INCLUDES +#include "common.h" + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeVersionCheck(int * ver1, int * ver2, int * ver3 ) { + { + try { + *ver1 = Dali::CORE_MAJOR_VERSION; + *ver2 = Dali::CORE_MINOR_VERSION; + *ver3 = Dali::CORE_MICRO_VERSION; + } CALL_CATCH_EXCEPTION(false); + } + return true; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_NUI_InternalAPIVersionCheck(int * version, int * reserved1, int * reserved2 ) +{ + try + { + if(Dali::CORE_MAJOR_VERSION == 1 && Dali::CORE_MINOR_VERSION == 2) + { + //by dali_1.2.85, nui_api_internal_version is set as 400 + if(Dali::CORE_MICRO_VERSION <= 85) + { + *version = 400; + *reserved1 = 0; + *reserved2 = 0; + return true; + } + //from dali_1.2.86, nui_api_internal_version is set as 401 + else if(Dali::CORE_MICRO_VERSION == 86) + { + *version = 401; + *reserved1 = 0; + *reserved2 = 0; + return true; + } + //gotten wrong native wrong version + else + { + *version = Dali::CORE_MAJOR_VERSION; + *reserved1 = Dali::CORE_MINOR_VERSION; + *reserved2 = Dali::CORE_MICRO_VERSION; + return false; + } + } + else if(Dali::CORE_MAJOR_VERSION == 1 && Dali::CORE_MINOR_VERSION == 3) + { + if(Dali::CORE_MICRO_VERSION <= 22) + { + //by dali_1.3.22, nui_api_internal_version is set as 500 + *version = 500; + *reserved1 = 0; + *reserved2 = 0; + return true; + } + else if(Dali::CORE_MICRO_VERSION <= 27) + { + //from dali_1.3.23 to dali 1.3.27, nui_api_internal_version is set as 501 + *version = 501; + *reserved1 = 0; + *reserved2 = 0; + return true; + } + else if(Dali::CORE_MICRO_VERSION <= 33) + { + //from dali_1.3.28, nui_api_internal_version is set as 502 + *version = 502; + *reserved1 = 0; + *reserved2 = 0; + return true; + } + else if(Dali::CORE_MICRO_VERSION <= 40) + { + //from dali_1.3.34, nui_api_internal_version is set as 503 + *version = 503; + *reserved1 = 0; + *reserved2 = 0; + return true; + } + else if(Dali::CORE_MICRO_VERSION <= 47) + { + //from dali_1.3.41, nui_api_internal_version is set as 504 + *version = 504; + *reserved1 = 0; + *reserved2 = 0; + return true; + } + else if(Dali::CORE_MICRO_VERSION <= 99) + { + //from dali_1.3.48, nui_api_internal_version is set as 505 + *version = 505; + *reserved1 = 0; + *reserved2 = 0; + return true; + } + else + { + *version = Dali::CORE_MAJOR_VERSION; + *reserved1 = Dali::CORE_MINOR_VERSION; + *reserved2 = Dali::CORE_MICRO_VERSION; + return false; + } + } + //something wrong + else + { + *version = Dali::CORE_MAJOR_VERSION; + *reserved1 = Dali::CORE_MINOR_VERSION; + *reserved2 = Dali::CORE_MICRO_VERSION; + return false; + } + } + CALL_CATCH_EXCEPTION(false); + return false; +} + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/common/view-wrapper-impl-wrap.cpp b/dali-csharp-binder/common/view-wrapper-impl-wrap.cpp new file mode 100755 index 00000000..de6935a2 --- /dev/null +++ b/dali-csharp-binder/common/view-wrapper-impl-wrap.cpp @@ -0,0 +1,975 @@ +/* + * Copyright (c) 2020 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. + * + */ + +// CLASS HEADER +#include "view-wrapper-impl-wrap.h" + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include "nui-view-accessible.h" + +#ifdef __cplusplus +extern "C" { +#endif + +SwigDirector_ViewWrapperImpl::SwigDirector_ViewWrapperImpl(Dali::Toolkit::Internal::ControlWrapper::CustomControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::ControlWrapper(behaviourFlags) { + swig_init_callbacks(); +} + +SwigDirector_ViewWrapperImpl::~SwigDirector_ViewWrapperImpl() { + +} + + +void SwigDirector_ViewWrapperImpl::OnSceneConnection(int depth) { + swig_callbackOnSceneConnection(depth); + + Dali::Toolkit::Internal::Control::OnSceneConnection(depth); +} + +void SwigDirector_ViewWrapperImpl::OnSceneDisconnection() { + swig_callbackOnSceneDisconnection(); + + Dali::Toolkit::Internal::Control::OnSceneDisconnection(); +} + +void SwigDirector_ViewWrapperImpl::OnChildAdd(Dali::Actor &child) { + void * jchild = (Dali::Actor *) &child; + swig_callbackOnChildAdd(jchild); + + Dali::Toolkit::Internal::Control::OnChildAdd( child ); +} + +void SwigDirector_ViewWrapperImpl::OnChildRemove(Dali::Actor &child) { + void * jchild = (Dali::Actor *) &child; + swig_callbackOnChildRemove(jchild); + + Dali::Toolkit::Internal::Control::OnChildRemove( child ); +} + +void SwigDirector_ViewWrapperImpl::OnPropertySet(Dali::Property::Index index, const Dali::Property::Value& propertyValue) { + int jindex ; + void * jpropertyValue ; + + jindex = index; + jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue); + swig_callbackOnPropertySet(jindex, jpropertyValue); + + Dali::Toolkit::Internal::ControlWrapper::OnPropertySet(index,propertyValue); +} + +void SwigDirector_ViewWrapperImpl::OnSizeSet(Dali::Vector3 const &targetSize) { + swig_callbackOnSizeSet((Dali::Vector3 *) &targetSize); + + Dali::Toolkit::Internal::Control::OnSizeSet(targetSize); +} + +void SwigDirector_ViewWrapperImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) { + swig_callbackOnSizeAnimation(new Dali::Animation(animation), (Dali::Vector3 *) &targetSize); + + Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize); +} + +bool SwigDirector_ViewWrapperImpl::OnKeyEvent(Dali::KeyEvent const &event) { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + void * jarg0 = 0 ; + + if (!swig_callbackOnKeyEvent) { + return Dali::Toolkit::Internal::Control::OnKeyEvent(event); + } else { + jarg0 = (Dali::KeyEvent *) &event; + jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0); + c_result = jresult ? true : false; + } + return c_result; +} + +void SwigDirector_ViewWrapperImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) { + void * jsize = 0 ; + void * jcontainer = 0 ; + + jsize = (Dali::Vector2 *) &size; + jcontainer = (Dali::RelayoutContainer *) &container; + swig_callbackOnRelayout(jsize, jcontainer); + + Dali::Toolkit::Internal::Control::OnRelayout(size,container); +} + +void SwigDirector_ViewWrapperImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) { + int jpolicy ; + int jdimension ; + + jpolicy = (int)policy; + jdimension = (int)dimension; + swig_callbackOnSetResizePolicy(jpolicy, jdimension); + + Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension); +} + +Dali::Vector3 SwigDirector_ViewWrapperImpl::GetNaturalSize() { + Dali::Vector3 c_result ; + void * jresult = 0 ; + + if (!swig_callbackGetNaturalSize) { + return Dali::Toolkit::Internal::Control::GetNaturalSize(); + } else { + jresult = (void *) swig_callbackGetNaturalSize(); + if (!jresult) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0); + return c_result; + } + + // Tizen.NUI.ViewWrapperImpl.DirectorGetNaturalSize() is assigned to swig_callbackGetNaturalSize(). + // Tizen.NUI.ViewWrapperImpl.DirectorGetNaturalSize() returns Dali::Vector2. + // Moreover, Dali::Vector3 supports operator '=' with Dali::Vector2. + // Not to cause ASAN heap-buffer-overflow issue here, casting Dali::Vector2 and assigning it to Dali::Vector3 is required. + c_result = *(Dali::Vector2 *)jresult; + } + return c_result; +} + +float SwigDirector_ViewWrapperImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) { + float c_result = SwigValueInit< float >() ; + float jresult = 0 ; + void * jchild = 0 ; + int jdimension ; + + if (!swig_callbackCalculateChildSize) { + return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension); + } else { + jchild = (Dali::Actor *) &child; + jdimension = (int)dimension; + jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension); + c_result = (float)jresult; + } + return c_result; +} + +float SwigDirector_ViewWrapperImpl::GetHeightForWidth(float width) { + float c_result = SwigValueInit< float >() ; + float jresult = 0 ; + float jwidth ; + + if (!swig_callbackGetHeightForWidth) { + return Dali::Toolkit::Internal::Control::GetHeightForWidth(width); + } else { + jwidth = width; + jresult = (float) swig_callbackGetHeightForWidth(jwidth); + c_result = (float)jresult; + } + return c_result; +} + +float SwigDirector_ViewWrapperImpl::GetWidthForHeight(float height) { + float c_result = SwigValueInit< float >() ; + float jresult = 0 ; + float jheight ; + + if (!swig_callbackGetWidthForHeight) { + return Dali::Toolkit::Internal::Control::GetWidthForHeight(height); + } else { + jheight = height; + jresult = (float) swig_callbackGetWidthForHeight(jheight); + c_result = (float)jresult; + } + return c_result; +} + +bool SwigDirector_ViewWrapperImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + int jdimension ; + + if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) { + return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension); + } else { + jdimension = (int)dimension; + jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension); + c_result = jresult ? true : false; + } + return c_result; +} + +void SwigDirector_ViewWrapperImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) { + int jdimension ; + + jdimension = (int)dimension; + swig_callbackOnCalculateRelayoutSize(jdimension); + + Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension); +} + +void SwigDirector_ViewWrapperImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) { + float jsize ; + int jdimension ; + + jsize = size; + jdimension = (int)dimension; + swig_callbackOnLayoutNegotiated(jsize, jdimension); + + Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension); +} + +void SwigDirector_ViewWrapperImpl::OnInitialize() { + swig_callbackOnInitialize(); + + Dali::Toolkit::Internal::Control::OnInitialize(); +} + +void SwigDirector_ViewWrapperImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) { + void * jstyleManager ; + int jchange ; + + jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager); + jchange = (int)change; + swig_callbackOnStyleChange(jstyleManager, jchange); + + Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change); +} + +bool SwigDirector_ViewWrapperImpl::OnAccessibilityActivated() { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + + if (!swig_callbackOnAccessibilityActivated) { + return Dali::Toolkit::Internal::Control::OnAccessibilityActivated(); + } else { + jresult = (unsigned int) swig_callbackOnAccessibilityActivated(); + c_result = jresult ? true : false; + } + return c_result; +} + +bool SwigDirector_ViewWrapperImpl::OnAccessibilityPan(Dali::PanGesture gesture) { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + void * jgesture ; + + if (!swig_callbackOnAccessibilityPan) { + return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture); + } else { + jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture); + jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture); + c_result = jresult ? true : false; + } + return c_result; +} + +bool SwigDirector_ViewWrapperImpl::OnAccessibilityValueChange(bool isIncrease) { + bool c_result = SwigValueInit< bool >(); + unsigned int jresult = 0; + unsigned int jisIncrease; + + if (!swig_callbackOnAccessibilityValueChange) { + return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease); + } else { + jisIncrease = isIncrease; + jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease); + c_result = jresult ? true : false; + } + return c_result; +} + +bool SwigDirector_ViewWrapperImpl::OnAccessibilityZoom() { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + + if (!swig_callbackOnAccessibilityZoom) { + return Dali::Toolkit::Internal::Control::OnAccessibilityZoom(); + } else { + jresult = (unsigned int) swig_callbackOnAccessibilityZoom(); + c_result = jresult ? true : false; + } + return c_result; +} + +Dali::Toolkit::DevelControl::ControlAccessible* SwigDirector_ViewWrapperImpl::CreateAccessibleObject() { + return new NUIViewAccessible(Self()); +} + +void SwigDirector_ViewWrapperImpl::OnKeyInputFocusGained() { + swig_callbackOnKeyInputFocusGained(); + + Dali::Toolkit::Internal::Control::OnKeyInputFocusGained(); +} + +void SwigDirector_ViewWrapperImpl::OnKeyInputFocusLost() { + swig_callbackOnKeyInputFocusLost(); + + Dali::Toolkit::Internal::Control::OnKeyInputFocusLost(); +} + +Dali::Actor SwigDirector_ViewWrapperImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) { + Dali::Actor c_result ; + void * jresult = 0 ; + int jdirection ; + unsigned int jloopEnabled ; + + if (!swig_callbackGetNextKeyboardFocusableActor) { + return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled); + } else { + jdirection = (int)direction; + jloopEnabled = loopEnabled; + jresult = (void *) swig_callbackGetNextKeyboardFocusableActor((void*)((Dali::Actor*)¤tFocusedActor), jdirection, jloopEnabled); + if (!jresult) { + // Return empty base handle when NUI returns null. + return c_result; + } + c_result = *(Dali::Actor *)jresult; + } + return c_result; +} + +void SwigDirector_ViewWrapperImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) { + swig_callbackOnKeyboardFocusChangeCommitted((void*)((Dali::Actor*)&commitedFocusableActor)); + + Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor); +} + +bool SwigDirector_ViewWrapperImpl::OnKeyboardEnter() { + bool c_result = SwigValueInit< bool >() ; + unsigned int jresult = 0 ; + + if (!swig_callbackOnKeyboardEnter) { + return Dali::Toolkit::Internal::Control::OnKeyboardEnter(); + } else { + jresult = (unsigned int) swig_callbackOnKeyboardEnter(); + c_result = jresult ? true : false; + } + return c_result; +} + +void SwigDirector_ViewWrapperImpl::OnPinch(Dali::PinchGesture const &pinch) { + void * jpinch = 0 ; + jpinch = (Dali::PinchGesture *) &pinch; + swig_callbackOnPinch(jpinch); + + Dali::Toolkit::Internal::Control::OnPinch(pinch); +} + +void SwigDirector_ViewWrapperImpl::OnPan(Dali::PanGesture const &pan) { + void * jpan = 0 ; + jpan = (Dali::PanGesture *) &pan; + swig_callbackOnPan(jpan); + + Dali::Toolkit::Internal::Control::OnPan(pan); +} + +void SwigDirector_ViewWrapperImpl::OnTap(Dali::TapGesture const &tap) { + void * jtap = 0 ; + jtap = (Dali::TapGesture *) &tap; + swig_callbackOnTap(jtap); + + Dali::Toolkit::Internal::Control::OnTap(tap); +} + +void SwigDirector_ViewWrapperImpl::OnLongPress(Dali::LongPressGesture const &longPress) { + void * jlongPress = 0 ; + + jlongPress = (Dali::LongPressGesture *) &longPress; + swig_callbackOnLongPress(jlongPress); + + Dali::Toolkit::Internal::Control::OnLongPress(longPress); +} + +Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewWrapperImpl::GetControlExtension() { + return Dali::Toolkit::Internal::Control::GetControlExtension(); +} + +void SwigDirector_ViewWrapperImpl::swig_connect_director(SWIG_Callback0_t callbackOnSceneConnection, SWIG_Callback1_t callbackOnSceneDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) { + swig_callbackOnSceneConnection = callbackOnSceneConnection; + swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection; + swig_callbackOnChildAdd = callbackOnChildAdd; + swig_callbackOnChildRemove = callbackOnChildRemove; + swig_callbackOnPropertySet = callbackOnPropertySet; + swig_callbackOnSizeSet = callbackOnSizeSet; + swig_callbackOnSizeAnimation = callbackOnSizeAnimation; + swig_callbackOnKeyEvent = callbackOnKeyEvent; + swig_callbackOnRelayout = callbackOnRelayout; + swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy; + swig_callbackGetNaturalSize = callbackGetNaturalSize; + swig_callbackCalculateChildSize = callbackCalculateChildSize; + swig_callbackGetHeightForWidth = callbackGetHeightForWidth; + swig_callbackGetWidthForHeight = callbackGetWidthForHeight; + swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0; + swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1; + swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize; + swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated; + swig_callbackOnInitialize = callbackOnInitialize; + swig_callbackOnStyleChange = callbackOnStyleChange; + swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated; + swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan; + swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange; + swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom; + swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained; + swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost; + swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor; + swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted; + swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter; + swig_callbackOnPinch = callbackOnPinch; + swig_callbackOnPan = callbackOnPan; + swig_callbackOnTap = callbackOnTap; + swig_callbackOnLongPress = callbackOnLongPress; + swig_callbackSignalConnected = callbackSignalConnected; + swig_callbackSignalDisconnected = callbackSignalDisconnected; +} + +void SwigDirector_ViewWrapperImpl::swig_init_callbacks() { + swig_callbackOnSceneConnection = 0; + swig_callbackOnSceneDisconnection = 0; + swig_callbackOnChildAdd = 0; + swig_callbackOnChildRemove = 0; + swig_callbackOnPropertySet = 0; + swig_callbackOnSizeSet = 0; + swig_callbackOnSizeAnimation = 0; + swig_callbackOnKeyEvent = 0; + swig_callbackOnRelayout = 0; + swig_callbackOnSetResizePolicy = 0; + swig_callbackGetNaturalSize = 0; + swig_callbackCalculateChildSize = 0; + swig_callbackGetHeightForWidth = 0; + swig_callbackGetWidthForHeight = 0; + swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0; + swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0; + swig_callbackOnCalculateRelayoutSize = 0; + swig_callbackOnLayoutNegotiated = 0; + swig_callbackOnInitialize = 0; + swig_callbackOnStyleChange = 0; + swig_callbackOnAccessibilityActivated = 0; + swig_callbackOnAccessibilityPan = 0; + swig_callbackOnAccessibilityValueChange = 0; + swig_callbackOnAccessibilityZoom = 0; + swig_callbackOnKeyInputFocusGained = 0; + swig_callbackOnKeyInputFocusLost = 0; + swig_callbackGetNextKeyboardFocusableActor = 0; + swig_callbackOnKeyboardFocusChangeCommitted = 0; + swig_callbackOnKeyboardEnter = 0; + swig_callbackOnPinch = 0; + swig_callbackOnPan = 0; + swig_callbackOnTap = 0; + swig_callbackOnLongPress = 0; + swig_callbackSignalConnected = 0; + swig_callbackSignalDisconnected = 0; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ViewWrapperImpl_CONTROL_BEHAVIOUR_FLAG_COUNT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_FLAG_COUNT; + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewWrapperImpl(int jarg1) { + void * jresult ; + Dali::Toolkit::Internal::ControlWrapper::CustomControlBehaviour arg1 ; + Dali::Toolkit::Internal::ControlWrapper *result = 0 ; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper::CustomControlBehaviour)jarg1; + { + try { + result = (Dali::Toolkit::Internal::ControlWrapper *)new SwigDirector_ViewWrapperImpl(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewWrapperImpl_New(char * jarg1, void * jarg2) { + void * jresult ; + std::string arg1 ; + Dali::Toolkit::Internal::ControlWrapper *arg2 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Toolkit::ControlWrapper result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + (&arg1)->assign(jarg1); + arg2 = (Dali::Toolkit::Internal::ControlWrapper *)jarg2; + { + try { + result = Dali::Toolkit::Internal::ControlWrapper::New(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ControlWrapper((const Dali::Toolkit::ControlWrapper &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewWrapperImpl(void * jarg1) { + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + { + try { + if (arg1) + { + arg1->Unreference(); + } + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewWrapperImpl_director_connect(void *objarg, SwigDirector_ViewWrapperImpl::SWIG_Callback0_t callback0, SwigDirector_ViewWrapperImpl::SWIG_Callback1_t callback1, SwigDirector_ViewWrapperImpl::SWIG_Callback2_t callback2, SwigDirector_ViewWrapperImpl::SWIG_Callback3_t callback3, SwigDirector_ViewWrapperImpl::SWIG_Callback4_t callback4, SwigDirector_ViewWrapperImpl::SWIG_Callback5_t callback5, SwigDirector_ViewWrapperImpl::SWIG_Callback6_t callback6, SwigDirector_ViewWrapperImpl::SWIG_Callback9_t callback9, SwigDirector_ViewWrapperImpl::SWIG_Callback11_t callback11, SwigDirector_ViewWrapperImpl::SWIG_Callback12_t callback12, SwigDirector_ViewWrapperImpl::SWIG_Callback13_t callback13, SwigDirector_ViewWrapperImpl::SWIG_Callback14_t callback14, SwigDirector_ViewWrapperImpl::SWIG_Callback15_t callback15, SwigDirector_ViewWrapperImpl::SWIG_Callback16_t callback16, SwigDirector_ViewWrapperImpl::SWIG_Callback17_t callback17, SwigDirector_ViewWrapperImpl::SWIG_Callback18_t callback18, SwigDirector_ViewWrapperImpl::SWIG_Callback19_t callback19, SwigDirector_ViewWrapperImpl::SWIG_Callback20_t callback20, SwigDirector_ViewWrapperImpl::SWIG_Callback21_t callback21, SwigDirector_ViewWrapperImpl::SWIG_Callback24_t callback24, SwigDirector_ViewWrapperImpl::SWIG_Callback25_t callback25, SwigDirector_ViewWrapperImpl::SWIG_Callback26_t callback26, SwigDirector_ViewWrapperImpl::SWIG_Callback28_t callback28, SwigDirector_ViewWrapperImpl::SWIG_Callback29_t callback29, SwigDirector_ViewWrapperImpl::SWIG_Callback30_t callback30, SwigDirector_ViewWrapperImpl::SWIG_Callback31_t callback31, SwigDirector_ViewWrapperImpl::SWIG_Callback32_t callback32, SwigDirector_ViewWrapperImpl::SWIG_Callback33_t callback33, SwigDirector_ViewWrapperImpl::SWIG_Callback34_t callback34, SwigDirector_ViewWrapperImpl::SWIG_Callback35_t callback35, SwigDirector_ViewWrapperImpl::SWIG_Callback36_t callback36, SwigDirector_ViewWrapperImpl::SWIG_Callback37_t callback37, SwigDirector_ViewWrapperImpl::SWIG_Callback38_t callback38, SwigDirector_ViewWrapperImpl::SWIG_Callback39_t callback39, SwigDirector_ViewWrapperImpl::SWIG_Callback40_t callback40) { + Dali::Toolkit::Internal::ControlWrapper *obj = (Dali::Toolkit::Internal::ControlWrapper *)objarg; + SwigDirector_ViewWrapperImpl *director = dynamic_cast(obj); + if (director) { + director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback9, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback24, callback25, callback26, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetControlWrapperImpl__SWIG_0(void * jarg1) { + void * jresult ; + Dali::Toolkit::ControlWrapper *arg1 = 0 ; + Dali::Toolkit::Internal::ControlWrapper *result = 0 ; + + arg1 = (Dali::Toolkit::ControlWrapper *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ControlWrapper & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::Internal::ControlWrapper *) &Dali::Toolkit::GetControlWrapperImpl(*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewWrapper_New(char * jarg1, void * jarg2) { + void * jresult ; + std::string arg1 ; + Dali::Toolkit::Internal::ControlWrapper *arg2 = 0 ; + Dali::Toolkit::ControlWrapper result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + (&arg1)->assign(jarg1); + arg2 = (Dali::Toolkit::Internal::ControlWrapper *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::ControlWrapper & type is null", 0); + return 0; + } + { + try { + result = Dali::Toolkit::ControlWrapper::New(arg1,*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ControlWrapper((const Dali::Toolkit::ControlWrapper &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewWrapper__SWIG_0() { + void * jresult ; + Dali::Toolkit::ControlWrapper *result = 0 ; + + { + try { + result = (Dali::Toolkit::ControlWrapper *)new Dali::Toolkit::ControlWrapper(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewWrapper(void * jarg1) { + Dali::Toolkit::ControlWrapper *arg1 = (Dali::Toolkit::ControlWrapper *) 0 ; + + arg1 = (Dali::Toolkit::ControlWrapper *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewWrapper__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::ControlWrapper *arg1 = 0 ; + Dali::Toolkit::ControlWrapper *result = 0 ; + + arg1 = (Dali::Toolkit::ControlWrapper *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ControlWrapper const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::ControlWrapper *)new Dali::Toolkit::ControlWrapper((Dali::Toolkit::ControlWrapper const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewWrapper_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::ControlWrapper *arg1 = (Dali::Toolkit::ControlWrapper *) 0 ; + Dali::Toolkit::ControlWrapper *arg2 = 0 ; + Dali::Toolkit::ControlWrapper *result = 0 ; + + arg1 = (Dali::Toolkit::ControlWrapper *)jarg1; + arg2 = (Dali::Toolkit::ControlWrapper *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ControlWrapper const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::ControlWrapper *) &(arg1)->operator =((Dali::Toolkit::ControlWrapper const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewWrapper_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::ControlWrapper 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::ControlWrapper::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ControlWrapper((const Dali::Toolkit::ControlWrapper &)result); + return jresult; +} + +SWIGEXPORT Dali::Toolkit::Internal::Control * SWIGSTDCALL CSharp_Dali_ViewWrapperImpl_SWIGUpcast(Dali::Toolkit::Internal::ControlWrapper *jarg1) { + return (Dali::Toolkit::Internal::Control *)jarg1; +} + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ViewWrapper_SWIGUpcast(Dali::Toolkit::ControlWrapper *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_ViewWrapperImpl_RelayoutRequest(void * jarg1) { + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + { + try { + (arg1)->RelayoutRequest(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_ViewWrapperImpl_GetHeightForWidthBase(void * jarg1, float jarg2) { + float jresult ; + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + float arg2 ; + float result; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (float)(arg1)->GetHeightForWidthBase(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_ViewWrapperImpl_GetWidthForHeightBase(void * jarg1, float jarg2) { + float jresult ; + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + float arg2 ; + float result; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (float)(arg1)->GetWidthForHeightBase(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_ViewWrapperImpl_CalculateChildSizeBase(void * jarg1, void * jarg2, int jarg3) { + float jresult ; + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Actor *arg2 = 0 ; + Dali::Dimension::Type arg3 ; + float result; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (Dali::Actor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); + return 0; + } + arg3 = (Dali::Dimension::Type)jarg3; + { + try { + result = (float)(arg1)->CalculateChildSizeBase((Dali::Actor const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ViewWrapperImpl_RelayoutDependentOnChildrenBase__SWIG_0(void * jarg1, int jarg2) { + unsigned int jresult ; + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Dimension::Type arg2 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (Dali::Dimension::Type)jarg2; + { + try { + result = (bool)(arg1)->RelayoutDependentOnChildrenBase(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ViewWrapperImpl_RelayoutDependentOnChildrenBase__SWIG_1(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + { + try { + result = (bool)(arg1)->RelayoutDependentOnChildrenBase(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_ViewWrapperImpl_RegisterVisual__SWIG_0(void * jarg1, int jarg2, void * jarg3) { + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Property::Index arg2 ; + Dali::Toolkit::Visual::Base *arg3 = 0 ; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + arg3 = (Dali::Toolkit::Visual::Base *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base & type is null", 0); + return ; + } + { + try { + (arg1)->RegisterVisual(arg2,*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_ViewWrapperImpl_RegisterVisual__SWIG_1(void * jarg1, int jarg2, void * jarg3, unsigned int jarg4) { + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Property::Index arg2 ; + Dali::Toolkit::Visual::Base *arg3 = 0 ; + bool arg4 ; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + arg3 = (Dali::Toolkit::Visual::Base *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base & type is null", 0); + return ; + } + arg4 = jarg4 ? true : false; + { + try { + (arg1)->RegisterVisual(arg2,*arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_ViewWrapperImpl_UnregisterVisual(void * jarg1, int jarg2) { + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Property::Index arg2 ; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + { + try { + (arg1)->UnregisterVisual(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_ViewWrapperImpl_GetVisual(void * jarg1, int jarg2) { + void * jresult ; + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Property::Index arg2 ; + Dali::Toolkit::Visual::Base result; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + { + try { + result = ((Dali::Toolkit::Internal::ControlWrapper const *)arg1)->GetVisual(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_ViewWrapperImpl_EnableVisual(void * jarg1, int jarg2, unsigned int jarg3) { + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Property::Index arg2 ; + bool arg3 ; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + arg3 = jarg3 ? true : false; + { + try { + (arg1)->EnableVisual(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ViewWrapperImpl_IsVisualEnabled(void * jarg1, int jarg2) { + unsigned int jresult ; + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Property::Index arg2 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (Dali::Property::Index)jarg2; + { + try { + result = (bool)((Dali::Toolkit::Internal::ControlWrapper const *)arg1)->IsVisualEnabled(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_ViewWrapperImpl_CreateTransition(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + Dali::Toolkit::TransitionData *arg2 = 0 ; + Dali::Animation result; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = (Dali::Toolkit::TransitionData *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0); + return 0; + } + { + try { + result = (arg1)->CreateTransition((Dali::Toolkit::TransitionData const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Animation((const Dali::Animation &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_ViewWrapperImpl_EmitKeyInputFocusSignal(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + bool arg2 ; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->EmitKeyInputFocusSignal(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewWrapperImpl_ApplyThemeStyle(void * jarg1) { + Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; + + arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; + { + try { + (arg1)->ApplyThemeStyle(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/common/view-wrapper-impl-wrap.h b/dali-csharp-binder/common/view-wrapper-impl-wrap.h new file mode 100644 index 00000000..4381d964 --- /dev/null +++ b/dali-csharp-binder/common/view-wrapper-impl-wrap.h @@ -0,0 +1,213 @@ +#ifndef CSHARP_VIEW_WRAPPER_IMPL_H +#define CSHARP_VIEW_WRAPPER_IMPL_H + +/* + * Copyright (c) 2020 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include + +// INTERNAL INCLUDES +#include "common.h" + +class SwigDirector_ViewWrapperImpl : public Dali::Toolkit::Internal::ControlWrapper +{ +public: + + SwigDirector_ViewWrapperImpl(Dali::Toolkit::Internal::ControlWrapper::CustomControlBehaviour behaviourFlags); + virtual ~SwigDirector_ViewWrapperImpl(); + virtual void OnSceneConnection(int depth); + virtual void OnSceneConnectionSwigPublic(int depth) + { + Dali::Toolkit::Internal::Control::OnSceneConnection(depth); + } + virtual void OnSceneDisconnection(); + virtual void OnSceneDisconnectionSwigPublic() + { + Dali::Toolkit::Internal::Control::OnSceneDisconnection(); + } + virtual void OnChildAdd(Dali::Actor &child); + virtual void OnChildAddSwigPublic(Dali::Actor &child) + { + Dali::Toolkit::Internal::Control::OnChildAdd(child); + } + virtual void OnChildRemove(Dali::Actor &child); + virtual void OnChildRemoveSwigPublic(Dali::Actor &child) + { + Dali::Toolkit::Internal::Control::OnChildRemove(child); + } + virtual void OnPropertySet(Dali::Property::Index index, const Dali::Property::Value& propertyValue); + virtual void OnSizeSet(Dali::Vector3 const &targetSize); + virtual void OnSizeSetSwigPublic(Dali::Vector3 const &targetSize) + { + Dali::Toolkit::Internal::Control::OnSizeSet(targetSize); + } + virtual void OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize); + virtual void OnSizeAnimationSwigPublic(Dali::Animation &animation, Dali::Vector3 const &targetSize) + { + Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize); + } + virtual bool OnKeyEvent(Dali::KeyEvent const &event); + virtual bool OnKeyEventSwigPublic(Dali::KeyEvent const &event) + { + return Dali::Toolkit::Internal::Control::OnKeyEvent(event); + } + virtual void OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container); + virtual void OnRelayoutSwigPublic(Dali::Vector2 const &size, Dali::RelayoutContainer &container) + { + Dali::Toolkit::Internal::Control::OnRelayout(size,container); + } + virtual void OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension); + virtual void OnSetResizePolicySwigPublic(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) + { + Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension); + } + virtual Dali::Vector3 GetNaturalSize(); + virtual Dali::Vector3 GetNaturalSizeSwigPublic() + { + return Dali::Toolkit::Internal::Control::GetNaturalSize(); + } + virtual float CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension); + virtual float CalculateChildSizeSwigPublic(Dali::Actor const &child, Dali::Dimension::Type dimension) + { + return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension); + } + virtual float GetHeightForWidth(float width); + virtual float GetHeightForWidthSwigPublic(float width) + { + return Dali::Toolkit::Internal::Control::GetHeightForWidth(width); + } + virtual float GetWidthForHeight(float height); + virtual float GetWidthForHeightSwigPublic(float height) + { + return Dali::Toolkit::Internal::Control::GetWidthForHeight(height); + } + virtual bool RelayoutDependentOnChildren(Dali::Dimension::Type dimension = Dali::Dimension::ALL_DIMENSIONS); + virtual bool RelayoutDependentOnChildrenSwigPublic(Dali::Dimension::Type dimension = Dali::Dimension::ALL_DIMENSIONS) + { + return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension); + } + virtual void OnCalculateRelayoutSize(Dali::Dimension::Type dimension); + virtual void OnCalculateRelayoutSizeSwigPublic(Dali::Dimension::Type dimension) + { + Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension); + } + virtual void OnLayoutNegotiated(float size, Dali::Dimension::Type dimension); + virtual void OnLayoutNegotiatedSwigPublic(float size, Dali::Dimension::Type dimension) + { + Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension); + } + virtual void OnInitialize(); + virtual void OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change); + virtual bool OnAccessibilityActivated(); + virtual bool OnAccessibilityPan(Dali::PanGesture gesture); + virtual bool OnAccessibilityValueChange(bool isIncrease); + virtual bool OnAccessibilityZoom(); + + Dali::Toolkit::DevelControl::ControlAccessible* CreateAccessibleObject() override; + + virtual void OnKeyInputFocusGained(); + virtual void OnKeyInputFocusLost(); + virtual Dali::Actor GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled); + virtual void OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor); + virtual bool OnKeyboardEnter(); + virtual void OnPinch(Dali::PinchGesture const &pinch); + virtual void OnPan(Dali::PanGesture const &pan); + virtual void OnTap(Dali::TapGesture const &tap); + virtual void OnLongPress(Dali::LongPressGesture const &longPress); + virtual Dali::Toolkit::Internal::Control::Extension *GetControlExtension(); + + typedef void (SWIGSTDCALL* SWIG_Callback0_t)(int); + typedef void (SWIGSTDCALL* SWIG_Callback1_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback2_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback3_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback4_t)(int, void *); + typedef void (SWIGSTDCALL* SWIG_Callback5_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback6_t)(void *, void *); + typedef bool (SWIGSTDCALL* SWIG_Callback9_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback11_t)(void *, void *); + typedef void (SWIGSTDCALL* SWIG_Callback12_t)(int, int); + typedef void * (SWIGSTDCALL* SWIG_Callback13_t)(); + typedef float (SWIGSTDCALL* SWIG_Callback14_t)(void *, int); + typedef float (SWIGSTDCALL* SWIG_Callback15_t)(float); + typedef float (SWIGSTDCALL* SWIG_Callback16_t)(float); + typedef bool (SWIGSTDCALL* SWIG_Callback17_t)(int); + typedef bool (SWIGSTDCALL* SWIG_Callback18_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback19_t)(int); + typedef void (SWIGSTDCALL* SWIG_Callback20_t)(float, int); + typedef void (SWIGSTDCALL* SWIG_Callback21_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback22_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback23_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback24_t)(void *, int); + typedef bool (SWIGSTDCALL* SWIG_Callback25_t)(); + typedef bool (SWIGSTDCALL* SWIG_Callback26_t)(void *); + typedef bool (SWIGSTDCALL* SWIG_Callback28_t)(bool); + typedef bool (SWIGSTDCALL* SWIG_Callback29_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback30_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback31_t)(); + typedef void * (SWIGSTDCALL* SWIG_Callback32_t)(void *, int, bool); + typedef void (SWIGSTDCALL* SWIG_Callback33_t)(void *); + typedef bool (SWIGSTDCALL* SWIG_Callback34_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback35_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback36_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback37_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback38_t)(void *); + typedef void (SWIGSTDCALL* SWIG_Callback39_t)(void *, void *); + typedef void (SWIGSTDCALL* SWIG_Callback40_t)(void *, void *); + void swig_connect_director(SWIG_Callback0_t callbackOnSceneConnection, SWIG_Callback1_t callbackOnSceneDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected); + +private: + SWIG_Callback0_t swig_callbackOnSceneConnection; + SWIG_Callback1_t swig_callbackOnSceneDisconnection; + SWIG_Callback2_t swig_callbackOnChildAdd; + SWIG_Callback3_t swig_callbackOnChildRemove; + SWIG_Callback4_t swig_callbackOnPropertySet; + SWIG_Callback5_t swig_callbackOnSizeSet; + SWIG_Callback6_t swig_callbackOnSizeAnimation; + SWIG_Callback9_t swig_callbackOnKeyEvent; + SWIG_Callback11_t swig_callbackOnRelayout; + SWIG_Callback12_t swig_callbackOnSetResizePolicy; + SWIG_Callback13_t swig_callbackGetNaturalSize; + SWIG_Callback14_t swig_callbackCalculateChildSize; + SWIG_Callback15_t swig_callbackGetHeightForWidth; + SWIG_Callback16_t swig_callbackGetWidthForHeight; + SWIG_Callback17_t swig_callbackRelayoutDependentOnChildren__SWIG_0; + SWIG_Callback18_t swig_callbackRelayoutDependentOnChildren__SWIG_1; + SWIG_Callback19_t swig_callbackOnCalculateRelayoutSize; + SWIG_Callback20_t swig_callbackOnLayoutNegotiated; + SWIG_Callback21_t swig_callbackOnInitialize; + SWIG_Callback24_t swig_callbackOnStyleChange; + SWIG_Callback25_t swig_callbackOnAccessibilityActivated; + SWIG_Callback26_t swig_callbackOnAccessibilityPan; + SWIG_Callback28_t swig_callbackOnAccessibilityValueChange; + SWIG_Callback29_t swig_callbackOnAccessibilityZoom; + SWIG_Callback30_t swig_callbackOnKeyInputFocusGained; + SWIG_Callback31_t swig_callbackOnKeyInputFocusLost; + SWIG_Callback32_t swig_callbackGetNextKeyboardFocusableActor; + SWIG_Callback33_t swig_callbackOnKeyboardFocusChangeCommitted; + SWIG_Callback34_t swig_callbackOnKeyboardEnter; + SWIG_Callback35_t swig_callbackOnPinch; + SWIG_Callback36_t swig_callbackOnPan; + SWIG_Callback37_t swig_callbackOnTap; + SWIG_Callback38_t swig_callbackOnLongPress; + SWIG_Callback39_t swig_callbackSignalConnected; + SWIG_Callback40_t swig_callbackSignalDisconnected; + void swig_init_callbacks(); +}; + +#endif /* CSHARP_VIEW_WRAPPER_IMPL_H */ diff --git a/dali-csharp-binder/dali-adaptor/adaptor-wrap.cpp b/dali-csharp-binder/dali-adaptor/adaptor-wrap.cpp new file mode 100755 index 00000000..03c33933 --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/adaptor-wrap.cpp @@ -0,0 +1,128 @@ +/* + * Copyright (c) 2020 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Adaptor &) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Adaptor &) > const *self){ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Adaptor &) > *self,void (*func)(Dali::Adaptor &)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Adaptor &) > *self,void (*func)(Dali::Adaptor &)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Adaptor &) > *self,Dali::Adaptor &arg){ + self->Emit( arg ); +} + +#ifdef __cplusplus +extern "C" { +#endif + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Adaptor(void * jarg1) { + Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ; + + arg1 = (Dali::Adaptor *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_SetRenderRefreshRate(void * jarg1, unsigned int jarg2) { + Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Adaptor *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + (arg1)->SetRenderRefreshRate(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Adaptor_Get() { + void * jresult ; + Dali::Adaptor *result = 0 ; + + { + try { + result = (Dali::Adaptor *) &Dali::Adaptor::Get(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_FeedWheelEvent(void * jarg1, void * jarg2) { + Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ; + Dali::WheelEvent *arg2 = 0 ; + + arg1 = (Dali::Adaptor *)jarg1; + arg2 = (Dali::WheelEvent *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent & type is null", 0); + return ; + } + { + try { + (arg1)->FeedWheelEvent(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_FeedKeyEvent(void * jarg1, void * jarg2) { + Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ; + Dali::KeyEvent *arg2 = 0 ; + + arg1 = (Dali::Adaptor *)jarg1; + arg2 = (Dali::KeyEvent *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent & type is null", 0); + return ; + } + { + try { + (arg1)->FeedKeyEvent(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-adaptor/application-wrap.cpp b/dali-csharp-binder/dali-adaptor/application-wrap.cpp new file mode 100644 index 00000000..57488335 --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/application-wrap.cpp @@ -0,0 +1,1844 @@ +/* + * Copyright (c) 2022 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include +#include + +// INTERNAL INCLUDES +#include + +/* Callback for returning strings to C# without leaking memory */ +typedef char*(SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char*); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +namespace +{ +// keep argcs and argv so they're always available to DALi +// Note : This argments used only if argv comes externally. +int gArgC = 0; +char** gArgV = nullptr; + +void ReleaseArgVMemory() +{ + if(gArgV) + { + // free string data + for(int i = 0; i < gArgC + 1; ++i) + { + delete[] gArgV[i]; + } + delete[] gArgV; + gArgV = nullptr; + } + gArgC = 0; +} + +void GenerationArgV(int argc, char* argv) +{ + // TODO : What should we do if already generated argv exist? + ReleaseArgVMemory(); + // generate argv data from the C# args + int index = 0; + int length = 0; + char* retPtr = NULL; + char* nextPtr; + + gArgV = new char*[argc + 1]; + + for(retPtr = strtok_r(argv, " ", &nextPtr); + retPtr != NULL && index < argc; + retPtr = strtok_r(NULL, " ", &nextPtr)) + { + length = 0; + length = strlen(retPtr); + gArgV[index] = new char[length + 1]; + strncpy(gArgV[index], retPtr, length); + gArgV[index][length] = '\0'; + index++; + } + + while(index < argc) + { + //if jarg1 - index >1, maybe cause error. + gArgV[index] = NULL; + index++; + } + + gArgV[argc] = NULL; + gArgC = argc; +} + +} // unnamed namespace + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Empty(Dali::Signal const* self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__GetConnectionCount(Dali::Signal const* self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Connect(Dali::Signal* self, void (*func)(Dali::DeviceStatus::Battery::Status)) +{ + self->Connect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Disconnect(Dali::Signal* self, void (*func)(Dali::DeviceStatus::Battery::Status)) +{ + self->Disconnect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Emit(Dali::Signal* self, Dali::DeviceStatus::Battery::Status arg) +{ + self->Emit(arg); +} +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Empty(Dali::Signal const* self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__GetConnectionCount(Dali::Signal const* self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Connect(Dali::Signal* self, void (*func)(Dali::DeviceStatus::Memory::Status)) +{ + self->Connect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Disconnect(Dali::Signal* self, void (*func)(Dali::DeviceStatus::Memory::Status)) +{ + self->Disconnect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Emit(Dali::Signal* self, Dali::DeviceStatus::Memory::Status arg) +{ + self->Emit(arg); +} + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Empty(Dali::Signal const* self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__GetConnectionCount(Dali::Signal const* self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Connect(Dali::Signal* self, void (*func)(Dali::DeviceStatus::Orientation::Status)) +{ + self->Connect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Disconnect(Dali::Signal* self, void (*func)(Dali::DeviceStatus::Orientation::Status)) +{ + self->Disconnect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Emit(Dali::Signal* self, Dali::DeviceStatus::Orientation::Status arg) +{ + self->Emit(arg); +} + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal const* self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal const* self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal* self, void (*func)(Dali::Application&)) +{ + self->Connect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal* self, void (*func)(Dali::Application&)) +{ + self->Disconnect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal* self, Dali::Application& arg) +{ + self->Emit(arg); +} + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal const* self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount(Dali::Signal const* self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(Dali::Signal* self, void (*func)(Dali::Application&, void*)) +{ + self->Connect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(Dali::Signal* self, void (*func)(Dali::Application&, void*)) +{ + self->Disconnect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(Dali::Signal* self, Dali::Application& arg1, void* arg2) +{ + self->Emit(arg1, arg2); +} + +#ifdef __cplusplus +extern "C" { +#endif + +/*Application binding*/ +SWIGEXPORT Dali::BaseHandle* SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application* jarg1) +{ + return (Dali::BaseHandle*)jarg1; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_PreInitialize() +{ + ApplicationPreInitialize(nullptr, nullptr); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() +{ + void* jresult; + Dali::Application result; + + { + try + { + result = Dali::Application::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Application((const Dali::Application&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) +{ + void* jresult; + + Dali::Application result; + { + try + { + result = Dali::Application::New(nullptr, nullptr); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Application((const Dali::Application&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char* jarg3) +{ + void* jresult; + std::string* arg3 = 0; + + Dali::Application result; + if(!jarg3) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg3_str(jarg3); + arg3 = &arg3_str; + { + try + { + result = Dali::Application::New(nullptr, nullptr, (std::string const&)*arg3); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Application((const Dali::Application&)result); + + //argout typemap for const std::string& + + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char* jarg3, int jarg4) +{ + void* jresult; + Dali::Application::WINDOW_MODE arg4; + + Dali::Application result; + if(!jarg3) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg3(jarg3); + arg4 = (Dali::Application::WINDOW_MODE)jarg4; + { + try + { + result = Dali::Application::New(nullptr, nullptr, arg3, arg4); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Application((const Dali::Application&)result); + + //argout typemap for const std::string& + + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__MANUAL_4(int jarg1, char* jarg2, char* jarg3, int jarg4) +{ + void* jresult; + int* argc = nullptr; + char*** argv = nullptr; + Dali::Application::WINDOW_MODE arg4; + Dali::Application result; + + { + // TODO : What should we do if already generated argv exist? + ReleaseArgVMemory(); + // generate argv data from the C# args + int index = 0; + int length = 0; + char* retPtr = NULL; + char* nextPtr; + + gArgV = new char*[jarg1 + 1]; + + for(retPtr = strtok_r(jarg2, " ", &nextPtr); + retPtr != NULL && index < jarg1; + retPtr = strtok_r(NULL, " ", &nextPtr)) + { + length = 0; + length = strlen(retPtr); + gArgV[index] = new char[length + 1]; + strncpy(gArgV[index], retPtr, length); + gArgV[index][length] = '\0'; + index++; + } + + while(index < jarg1) + { + //if jarg1 - index >1, maybe cause error. + gArgV[index] = NULL; + index++; + } + + gArgV[jarg1] = NULL; + gArgC = jarg1; + + argc = &gArgC; + argv = &gArgV; + } + + std::string arg3(jarg3); + arg4 = (Dali::Application::WINDOW_MODE)jarg4; + { + try + { + result = Dali::Application::New(argc, argv, arg3, arg4); + } + CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Application((const Dali::Application&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() +{ + void* jresult; + Dali::Application* result = 0; + + { + try + { + result = (Dali::Application*)new Dali::Application(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void* jarg1) +{ + void* jresult; + Dali::Application* arg1 = 0; + Dali::Application* result = 0; + + arg1 = (Dali::Application*)jarg1; + if(!arg1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Application*)new Dali::Application((Dali::Application const&)*arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_Assign(void* jarg1, void* jarg2) +{ + void* jresult; + Dali::Application* arg1 = (Dali::Application*)0; + Dali::Application* arg2 = 0; + Dali::Application* result = 0; + + arg1 = (Dali::Application*)jarg1; + arg2 = (Dali::Application*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Application*)&(arg1)->operator=((Dali::Application const&)*arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void* jarg1) +{ + Dali::Application* arg1 = (Dali::Application*)0; + + arg1 = (Dali::Application*)jarg1; + { + try + { + delete arg1; + ReleaseArgVMemory(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void* jarg1) +{ + Dali::Application* arg1 = (Dali::Application*)0; + + arg1 = (Dali::Application*)jarg1; + { + try + { + (arg1)->MainLoop(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void* jarg1) +{ + Dali::Application* arg1 = (Dali::Application*)0; + + arg1 = (Dali::Application*)jarg1; + { + try + { + (arg1)->Lower(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void* jarg1) +{ + Dali::Application* arg1 = (Dali::Application*)0; + + arg1 = (Dali::Application*)jarg1; + { + try + { + (arg1)->Quit(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void* jarg1, void* jarg2) +{ + unsigned int jresult; + Dali::Application* arg1 = (Dali::Application*)0; + Dali::CallbackBase* arg2 = (Dali::CallbackBase*)0; + bool result; + + arg1 = (Dali::Application*)jarg1; + arg2 = (Dali::CallbackBase*)jarg2; + { + try + { + result = (bool)(arg1)->AddIdle(arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_GetWindow(void* jarg1) +{ + void* jresult; + Dali::Application* arg1 = (Dali::Application*)0; + Dali::Window result; + + arg1 = (Dali::Application*)jarg1; + { + try + { + result = (arg1)->GetWindow(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Window((const Dali::Window&)result); + return jresult; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_GetWindowsListSize() +{ + unsigned int jresult; + Dali::WindowContainer result; + { + try + { + result = Dali::Adaptor::Get().GetWindows(); + jresult = result.size(); + } + CALL_CATCH_EXCEPTION(0); + } + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_GetWindowsFromList(unsigned int jarg1) +{ + void* jresult; + unsigned int index = jarg1; + Dali::WindowContainer result; + + { + try + { + result = Dali::Adaptor::Get().GetWindows(); + } + CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Window((const Dali::Window&)result[index]); + return jresult; +} + +SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() +{ + char* jresult; + std::string result; + + { + try + { + result = Dali::Application::GetResourcePath(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback((&result)->c_str()); + return jresult; +} + +SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Application_GetRegion(void* jarg1) +{ + char* jresult; + Dali::Application* arg1 = (Dali::Application*)0; + std::string result; + + arg1 = (Dali::Application*)jarg1; + { + try + { + result = (arg1)->GetRegion(); + } + CALL_CATCH_EXCEPTION(0); + } + jresult = SWIG_csharp_string_callback((&result)->c_str()); + return jresult; +} + +SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Application_GetLanguage(void* jarg1) +{ + char* jresult; + Dali::Application* arg1 = (Dali::Application*)0; + std::string result; + + arg1 = (Dali::Application*)jarg1; + { + try + { + result = (arg1)->GetLanguage(); + } + CALL_CATCH_EXCEPTION(0); + } + jresult = SWIG_csharp_string_callback((&result)->c_str()); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_InitSignal(void* jarg1) +{ + void* jresult; + Dali::Application* arg1 = (Dali::Application*)0; + Dali::Application::AppSignalType* result = 0; + + arg1 = (Dali::Application*)jarg1; + { + try + { + result = (Dali::Application::AppSignalType*)&(arg1)->InitSignal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void* jarg1) +{ + void* jresult; + Dali::Application* arg1 = (Dali::Application*)0; + Dali::Application::AppSignalType* result = 0; + + arg1 = (Dali::Application*)jarg1; + { + try + { + result = (Dali::Application::AppSignalType*)&(arg1)->TerminateSignal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void* jarg1) +{ + void* jresult; + Dali::Application* arg1 = (Dali::Application*)0; + Dali::Application::AppSignalType* result = 0; + + arg1 = (Dali::Application*)jarg1; + { + try + { + result = (Dali::Application::AppSignalType*)&(arg1)->PauseSignal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void* jarg1) +{ + void* jresult; + Dali::Application* arg1 = (Dali::Application*)0; + Dali::Application::AppSignalType* result = 0; + + arg1 = (Dali::Application*)jarg1; + { + try + { + result = (Dali::Application::AppSignalType*)&(arg1)->ResumeSignal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void* jarg1) +{ + void* jresult; + Dali::Application* arg1 = (Dali::Application*)0; + Dali::Application::AppSignalType* result = 0; + + arg1 = (Dali::Application*)jarg1; + { + try + { + result = (Dali::Application::AppSignalType*)&(arg1)->ResetSignal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void* jarg1) +{ + void* jresult; + Dali::Application* arg1 = (Dali::Application*)0; + Dali::Application::AppControlSignalType* result = 0; + + arg1 = (Dali::Application*)jarg1; + { + try + { + result = (Dali::Application::AppControlSignalType*)&(arg1)->AppControlSignal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void* jarg1) +{ + void* jresult; + Dali::Application* arg1 = (Dali::Application*)0; + Dali::Application::AppSignalType* result = 0; + + arg1 = (Dali::Application*)jarg1; + { + try + { + result = (Dali::Application::AppSignalType*)&(arg1)->LanguageChangedSignal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void* jarg1) +{ + void* jresult; + Dali::Application* arg1 = (Dali::Application*)0; + Dali::Application::AppSignalType* result = 0; + + arg1 = (Dali::Application*)jarg1; + { + try + { + result = (Dali::Application::AppSignalType*)&(arg1)->RegionChangedSignal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_LowBatterySignal(void* jarg1) +{ + void* jresult; + Dali::Application* arg1 = (Dali::Application*)0; + Dali::Application::LowBatterySignalType* result = 0; + + arg1 = (Dali::Application*)jarg1; + { + try + { + result = (Dali::Application::LowBatterySignalType*)&(arg1)->LowBatterySignal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_LowMemorySignal(void* jarg1) +{ + void* jresult; + Dali::Application* arg1 = (Dali::Application*)0; + Dali::Application::LowMemorySignalType* result = 0; + + arg1 = (Dali::Application*)jarg1; + { + try + { + result = (Dali::Application::LowMemorySignalType*)&(arg1)->LowMemorySignal(); + } + CALL_CATCH_EXCEPTION(0); + } + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignal(void* jarg1) +{ + void* jresult; + Dali::Application* arg1 = (Dali::Application*)0; + Dali::Application::DeviceOrientationChangedSignalType* result = 0; + + arg1 = (Dali::Application*)jarg1; + { + try + { + result = (Dali::Application::DeviceOrientationChangedSignalType*)&(arg1)->DeviceOrientationChangedSignal(); + } + CALL_CATCH_EXCEPTION(0); + } + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskInitSignal(void* app) +{ + void* jresult; + Dali::Application* application = (Dali::Application*)0; + Dali::Application::AppSignalType* result = 0; + + application = (Dali::Application*)app; + { + try + { + result = (Dali::Application::AppSignalType*)&(application)->TaskInitSignal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskTerminateSignal(void* app) +{ + void* jresult; + Dali::Application* application = (Dali::Application*)0; + Dali::Application::AppSignalType* result = 0; + + application = (Dali::Application*)app; + { + try + { + result = (Dali::Application::AppSignalType*)&(application)->TaskTerminateSignal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskAppControlSignal(void* app) +{ + void* jresult; + Dali::Application* application = (Dali::Application*)0; + Dali::Application::AppControlSignalType* result = 0; + + application = (Dali::Application*)app; + { + try + { + result = (Dali::Application::AppControlSignalType*)&(application)->TaskAppControlSignal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskLanguageChangedSignal(void* app) +{ + void* jresult; + Dali::Application* application = (Dali::Application*)0; + Dali::Application::AppSignalType* result = 0; + + application = (Dali::Application*)app; + { + try + { + result = (Dali::Application::AppSignalType*)&(application)->TaskLanguageChangedSignal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskRegionChangedSignal(void* app) +{ + void* jresult; + Dali::Application* application = (Dali::Application*)0; + Dali::Application::AppSignalType* result = 0; + + application = (Dali::Application*)app; + { + try + { + result = (Dali::Application::AppSignalType*)&(application)->TaskRegionChangedSignal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskLowBatterySignal(void* app) +{ + void* jresult; + Dali::Application* application = (Dali::Application*)0; + Dali::Application::LowBatterySignalType* result = 0; + + application = (Dali::Application*)app; + { + try + { + result = (Dali::Application::LowBatterySignalType*)&(application)->TaskLowBatterySignal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskLowMemorySignal(void* app) +{ + void* jresult; + Dali::Application* application = (Dali::Application*)0; + Dali::Application::LowMemorySignalType* result = 0; + + application = (Dali::Application*)app; + { + try + { + result = (Dali::Application::LowMemorySignalType*)&(application)->TaskLowMemorySignal(); + } + CALL_CATCH_EXCEPTION(0); + } + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskDeviceOrientationChangedSignal(void* app) +{ + void* jresult; + Dali::Application* application = (Dali::Application*)0; + Dali::Application::DeviceOrientationChangedSignalType* result = 0; + + application = (Dali::Application*)app; + { + try + { + result = (Dali::Application::DeviceOrientationChangedSignalType*)&(application)->TaskDeviceOrientationChangedSignal(); + } + CALL_CATCH_EXCEPTION(0); + } + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Empty(void* jarg1) +{ + unsigned int jresult; + Dali::Signal* arg1 = (Dali::Signal*)0; + bool result; + + arg1 = (Dali::Signal*)jarg1; + { + try + { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Empty((Dali::Signal const*)arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_GetConnectionCount(void* jarg1) +{ + unsigned long jresult; + Dali::Signal* arg1 = (Dali::Signal*)0; + std::size_t result; + + arg1 = (Dali::Signal*)jarg1; + { + try + { + result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__GetConnectionCount((Dali::Signal const*)arg1); + } + CALL_CATCH_EXCEPTION(0); + } + jresult = (unsigned long)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Connect(void* jarg1, void* jarg2) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + void (*arg2)(Dali::DeviceStatus::Battery::Status) = (void (*)(Dali::DeviceStatus::Battery::Status))0; + + arg1 = (Dali::Signal*)jarg1; + arg2 = (void (*)(Dali::DeviceStatus::Battery::Status))jarg2; + { + try + { + Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Connect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Disconnect(void* jarg1, void* jarg2) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + void (*arg2)(Dali::DeviceStatus::Battery::Status) = (void (*)(Dali::DeviceStatus::Battery::Status))0; + + arg1 = (Dali::Signal*)jarg1; + arg2 = (void (*)(Dali::DeviceStatus::Battery::Status))jarg2; + { + try + { + Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Disconnect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Emit(void* jarg1, void* jarg2) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + Dali::DeviceStatus::Battery::Status arg2; + Dali::DeviceStatus::Battery::Status* argp2; + + arg1 = (Dali::Signal*)jarg1; + argp2 = (Dali::DeviceStatus::Battery::Status*)jarg2; + if(!argp2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DeviceStatus::Battery::Status", 0); + return; + } + arg2 = *argp2; + { + try + { + Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Emit(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_new_LowBatterySignalType() +{ + void* jresult; + Dali::Signal* result = 0; + + { + try + { + result = (Dali::Signal*)new Dali::Signal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_LowBatterySignalType(void* jarg1) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + + arg1 = (Dali::Signal*)jarg1; + { + try + { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Empty(void* jarg1) +{ + unsigned int jresult; + Dali::Signal* arg1 = (Dali::Signal*)0; + bool result; + + arg1 = (Dali::Signal*)jarg1; + { + try + { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Empty((Dali::Signal const*)arg1); + } + CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_GetConnectionCount(void* jarg1) +{ + unsigned long jresult; + Dali::Signal* arg1 = (Dali::Signal*)0; + std::size_t result; + + arg1 = (Dali::Signal*)jarg1; + { + try + { + result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__GetConnectionCount((Dali::Signal const*)arg1); + } + CALL_CATCH_EXCEPTION(0); + } + jresult = (unsigned long)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Connect(void* jarg1, void* jarg2) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + void (*arg2)(Dali::DeviceStatus::Memory::Status) = (void (*)(Dali::DeviceStatus::Memory::Status))0; + + arg1 = (Dali::Signal*)jarg1; + arg2 = (void (*)(Dali::DeviceStatus::Memory::Status))jarg2; + { + try + { + Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Connect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Disconnect(void* jarg1, void* jarg2) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + void (*arg2)(Dali::DeviceStatus::Memory::Status) = (void (*)(Dali::DeviceStatus::Memory::Status))0; + + arg1 = (Dali::Signal*)jarg1; + arg2 = (void (*)(Dali::DeviceStatus::Memory::Status))jarg2; + { + try + { + Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Disconnect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Emit(void* jarg1, void* jarg2) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + Dali::DeviceStatus::Memory::Status arg2; + Dali::DeviceStatus::Memory::Status* argp2; + + arg1 = (Dali::Signal*)jarg1; + argp2 = (Dali::DeviceStatus::Memory::Status*)jarg2; + if(!argp2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DeviceStatus::Memory::Status", 0); + return; + } + arg2 = *argp2; + { + try + { + Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Emit(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_new_LowMemorySignalType() +{ + void* jresult; + Dali::Signal* result = 0; + + { + try + { + result = (Dali::Signal*)new Dali::Signal(); + } + CALL_CATCH_EXCEPTION(0); + } + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_LowMemorySignalType(void* jarg1) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + + arg1 = (Dali::Signal*)jarg1; + { + try + { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_Empty(void* jarg1) +{ + unsigned int jresult; + Dali::Signal* arg1 = (Dali::Signal*)0; + bool result; + + arg1 = (Dali::Signal*)jarg1; + { + try + { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Empty((Dali::Signal const*)arg1); + } + CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_GetConnectionCount(void* jarg1) +{ + unsigned long jresult; + Dali::Signal* arg1 = (Dali::Signal*)0; + std::size_t result; + + arg1 = (Dali::Signal*)jarg1; + { + try + { + result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__GetConnectionCount((Dali::Signal const*)arg1); + } + CALL_CATCH_EXCEPTION(0); + } + jresult = (unsigned long)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_Connect(void* jarg1, void* jarg2) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + void (*arg2)(Dali::DeviceStatus::Orientation::Status) = (void (*)(Dali::DeviceStatus::Orientation::Status))0; + + arg1 = (Dali::Signal*)jarg1; + arg2 = (void (*)(Dali::DeviceStatus::Orientation::Status))jarg2; + { + try + { + Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Connect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_Disconnect(void* jarg1, void* jarg2) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + void (*arg2)(Dali::DeviceStatus::Orientation::Status) = (void (*)(Dali::DeviceStatus::Orientation::Status))0; + + arg1 = (Dali::Signal*)jarg1; + arg2 = (void (*)(Dali::DeviceStatus::Orientation::Status))jarg2; + { + try + { + Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Disconnect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_Emit(void* jarg1, void* jarg2) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + Dali::DeviceStatus::Orientation::Status arg2; + Dali::DeviceStatus::Orientation::Status* argp2; + + arg1 = (Dali::Signal*)jarg1; + argp2 = (Dali::DeviceStatus::Orientation::Status*)jarg2; + if(!argp2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DeviceStatus::Orientation::Status", 0); + return; + } + arg2 = *argp2; + { + try + { + Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Emit(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_new_DeviceOrientationChangedSignalType() +{ + void* jresult; + Dali::Signal* result = 0; + + { + try + { + result = (Dali::Signal*)new Dali::Signal(); + } + CALL_CATCH_EXCEPTION(0); + } + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_DeviceOrientationChangedSignalType(void* jarg1) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + + arg1 = (Dali::Signal*)jarg1; + { + try + { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void* jarg1) +{ + unsigned int jresult; + Dali::Signal* arg1 = (Dali::Signal*)0; + bool result; + + arg1 = (Dali::Signal*)jarg1; + { + try + { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal const*)arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void* jarg1) +{ + unsigned long jresult; + Dali::Signal* arg1 = (Dali::Signal*)0; + std::size_t result; + + arg1 = (Dali::Signal*)jarg1; + { + try + { + result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal const*)arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void* jarg1, void* jarg2) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + void (*arg2)(Dali::Application&) = (void (*)(Dali::Application&))0; + + arg1 = (Dali::Signal*)jarg1; + arg2 = (void (*)(Dali::Application&))jarg2; + { + try + { + Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void* jarg1, void* jarg2) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + void (*arg2)(Dali::Application&) = (void (*)(Dali::Application&))0; + + arg1 = (Dali::Signal*)jarg1; + arg2 = (void (*)(Dali::Application&))jarg2; + { + try + { + Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void* jarg1, void* jarg2) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + Dali::Application* arg2 = 0; + + arg1 = (Dali::Signal*)jarg1; + arg2 = (Dali::Application*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0); + return; + } + { + try + { + Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1, *arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() +{ + void* jresult; + Dali::Signal* result = 0; + + { + try + { + result = (Dali::Signal*)new Dali::Signal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void* jarg1) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + + arg1 = (Dali::Signal*)jarg1; + { + try + { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void* jarg1) +{ + unsigned int jresult; + Dali::Signal* arg1 = (Dali::Signal*)0; + bool result; + + arg1 = (Dali::Signal*)jarg1; + { + try + { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal const*)arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void* jarg1) +{ + unsigned long jresult; + Dali::Signal* arg1 = (Dali::Signal*)0; + std::size_t result; + + arg1 = (Dali::Signal*)jarg1; + { + try + { + result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal const*)arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void* jarg1, void* jarg2) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + void (*arg2)(Dali::Application&, void*) = (void (*)(Dali::Application&, void*))0; + + arg1 = (Dali::Signal*)jarg1; + arg2 = (void (*)(Dali::Application&, void*))jarg2; + { + try + { + Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void* jarg1, void* jarg2) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + void (*arg2)(Dali::Application&, void*) = (void (*)(Dali::Application&, void*))0; + + arg1 = (Dali::Signal*)jarg1; + arg2 = (void (*)(Dali::Application&, void*))jarg2; + { + try + { + Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void* jarg1, void* jarg2, void* jarg3) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + Dali::Application* arg2 = 0; + void* arg3 = (void*)0; + + arg1 = (Dali::Signal*)jarg1; + arg2 = (Dali::Application*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0); + return; + } + arg3 = jarg3; + { + try + { + Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1, *arg2, arg3); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() +{ + void* jresult; + Dali::Signal* result = 0; + + { + try + { + result = (Dali::Signal*)new Dali::Signal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void* jarg1) +{ + Dali::Signal* arg1 = (Dali::Signal*)0; + + arg1 = (Dali::Signal*)jarg1; + { + try + { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } +} + +/*application-devel binding*/ + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_4(int jarg1, char* jarg3, int jarg4, void* jarg5) +{ + void* jresult; + int* argc = nullptr; + char*** argv = nullptr; + Dali::Application::WINDOW_MODE arg4; + Dali::PositionSize arg5; + Dali::PositionSize* argp5; + Dali::Application result; + + if(!jarg3) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg3(jarg3); + arg4 = (Dali::Application::WINDOW_MODE)jarg4; + argp5 = (Dali::PositionSize*)jarg5; + if(!argp5) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0); + return 0; + } + arg5 = *argp5; + { + try + { + result = Dali::Application::New(argc, argv, arg3, arg4, arg5); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Application((const Dali::Application&)result); + + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_5(int jarg1, char* jarg3, int jarg4, void* jarg5, int jarg6) +{ + void* jresult; + int* argc = nullptr; + char*** argv = nullptr; + Dali::Application::WINDOW_MODE arg4; + Dali::PositionSize arg5; + Dali::PositionSize* argp5; + Dali::WindowType arg6; + Dali::Application result; + + if(!jarg3) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg3(jarg3); + arg4 = (Dali::Application::WINDOW_MODE)jarg4; + argp5 = (Dali::PositionSize*)jarg5; + arg6 = (Dali::WindowType)jarg6; + + if(!argp5) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0); + return 0; + } + arg5 = *argp5; + { + try + { + result = Dali::DevelApplication::New(argc, argv, arg3, arg4, arg5, arg6); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Application((const Dali::Application&)result); + + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_6(int nuiArgc, char* nuiArgv, char* nuiStyleSheet, int nuiWindowMode, void* nuiPositionSize, bool nuiUseUiThread) +{ + void* jresult; + int* argc = nullptr; + char*** argv = nullptr; + Dali::Application::WINDOW_MODE windowMode; + Dali::PositionSize positionSize; + Dali::PositionSize* positionSizeP; + bool useUiThread; + Dali::Application result; + + if(!nuiStyleSheet) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string styleSheet(nuiStyleSheet); + windowMode = (Dali::Application::WINDOW_MODE)nuiWindowMode; + positionSizeP = (Dali::PositionSize*)nuiPositionSize; + useUiThread = nuiUseUiThread; + + if(!positionSizeP) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0); + return 0; + } + + GenerationArgV(nuiArgc, nuiArgv); + argc = &gArgC; + argv = &gArgV; + + positionSize = *positionSizeP; + { + try + { + result = Dali::Application::New(argc, argv, styleSheet, windowMode, positionSize, useUiThread); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Application((const Dali::Application&)result); + + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New_WithWindowSizePosition(int jarg1, char* jarg2, char* jarg3, int jarg4, void* jarg5) +{ + void* jresult; + int* argc = nullptr; + char*** argv = nullptr; + Dali::Application::WINDOW_MODE arg4; + Dali::PositionSize arg5; + Dali::PositionSize* argp5; + Dali::Application result; + + { + // TODO : What should we do if already generated argv exist? + ReleaseArgVMemory(); + // generate argv data from the C# args + int index = 0; + int length = 0; + char* retPtr = NULL; + char* nextPtr; + + gArgV = new char*[jarg1 + 1]; + + for(retPtr = strtok_r(jarg2, " ", &nextPtr); + retPtr != NULL && index < jarg1; + retPtr = strtok_r(NULL, " ", &nextPtr)) + { + length = 0; + length = strlen(retPtr); + gArgV[index] = new char[length + 1]; + strncpy(gArgV[index], retPtr, length); + gArgV[index][length] = '\0'; + index++; + } + + while(index < jarg1) + { + //if jarg1 - index >1, maybe cause error. + gArgV[index] = NULL; + index++; + } + + gArgV[jarg1] = NULL; + gArgC = jarg1; + + argc = &gArgC; + argv = &gArgV; + } + + std::string arg3(jarg3); + arg4 = (Dali::Application::WINDOW_MODE)jarg4; + argp5 = (Dali::PositionSize*)jarg5; + if(!argp5) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0); + return 0; + } + arg5 = *argp5; + { + try + { + result = Dali::Application::New(argc, argv, arg3, arg4, arg5); + } + CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Application((const Dali::Application&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New_WithWindowData(int nuiArgc, char* nuiArgv, char* nuiStyleSheet, bool nuiUIThread, void* nuiWindowData) +{ + void* jresult; + int* argc = nullptr; + char*** argv = nullptr; + Dali::WindowData* pWindowData; + Dali::Application result; + + { + // TODO : What should we do if already generated argv exist? + ReleaseArgVMemory(); + // generate argv data from the C# args + int index = 0; + int length = 0; + char* retPtr = NULL; + char* nextPtr; + + gArgV = new char*[nuiArgc + 1]; + + for(retPtr = strtok_r(nuiArgv, " ", &nextPtr); + retPtr != NULL && index < nuiArgc; + retPtr = strtok_r(NULL, " ", &nextPtr)) + { + length = 0; + length = strlen(retPtr); + gArgV[index] = new char[length + 1]; + strncpy(gArgV[index], retPtr, length); + gArgV[index][length] = '\0'; + index++; + } + + while(index < nuiArgc) + { + // if nuiArgc - index >1, maybe cause error. + gArgV[index] = NULL; + index++; + } + + gArgV[nuiArgc] = NULL; + gArgC = nuiArgc; + + argc = &gArgC; + argv = &gArgV; + } + + std::string styleSheet(nuiStyleSheet); + pWindowData = (Dali::WindowData*)nuiWindowData; + if(!pWindowData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0); + return 0; + } + + { + try + { + result = Dali::Application::New(argc, argv, styleSheet, nuiUIThread, *pWindowData); + } + CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Application((const Dali::Application&)result); + return jresult; +} + +SWIGEXPORT int32_t SWIGSTDCALL CSharp_Dali_Application_GetRenderThreadId(void* jarg1) +{ + Dali::Application* arg1 = (Dali::Application*)jarg1; + + int32_t result; + try + { + result = Dali::DevelApplication::GetRenderThreadId(*arg1); + } + CALL_CATCH_EXCEPTION(0); + return result; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-adaptor/atspi-wrap.cpp b/dali-csharp-binder/dali-adaptor/atspi-wrap.cpp new file mode 100755 index 00000000..c7acd4da --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/atspi-wrap.cpp @@ -0,0 +1,158 @@ +/* + * Copyright (c) 2019 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include + +// INTERNAL INCLUDES +#include + +#define NAMEOF(x) #x + +#ifdef __cplusplus +extern "C" { +#endif + +using callbackFuncType = void(*)(int); +callbackFuncType callBack; + +void sayTestCallback(std::string result) +{ + DALI_LOG_ERROR("sayTestCallback() result=%s ", result.c_str()); + + if(callBack) + { + if(result == "ReadingCancelled") + { + callBack(1); + } + else if(result == "ReadingStopped") + { + callBack(2); + } + else if(result == "ReadingSkipped") + { + callBack(3); + } + else if(result == "ReadingPaused") + { + callBack(4); + } + else if(result == "ReadingResumed") + { + callBack(5); + } + else + { + callBack(-1); + } + } +} + +SWIGEXPORT void SWIGSTDCALL csharp_dali_accessibility_say(char* arg1_text, bool arg2_discardable, void *arg3_callback) +{ + callBack = (callbackFuncType)arg3_callback; + + Dali::AtspiAccessibility::Say(std::string{arg1_text}, arg2_discardable, sayTestCallback); +} + +SWIGEXPORT void SWIGSTDCALL csharp_dali_accessibility_pause_resume(bool arg1_pause) +{ + if(arg1_pause) + { + Dali::AtspiAccessibility::Pause(); + } + else + { + Dali::AtspiAccessibility::Resume(); + } +} + +SWIGEXPORT void SWIGSTDCALL csharp_dali_accessibility_stop_reading(bool arg1_alsoNonDiscardable) +{ + Dali::AtspiAccessibility::StopReading(arg1_alsoNonDiscardable); +} + +SWIGEXPORT bool SWIGSTDCALL csharp_dali_accessibility_suppress_screen_reader(bool arg1_suppress) +{ + return Dali::AtspiAccessibility::SuppressScreenReader(arg1_suppress); +} + +SWIGEXPORT void SWIGSTDCALL csharp_dali_accessibility_BridgeEnableAutoInit() +{ + Dali::Accessibility::Bridge::EnableAutoInit(); +} + +SWIGEXPORT void SWIGSTDCALL csharp_dali_accessibility_BridgeDisableAutoInit() +{ + Dali::Accessibility::Bridge::DisableAutoInit(); +} + +SWIGEXPORT bool SWIGSTDCALL csharp_dali_accessibility_IsEnabled() +{ + return Dali::AtspiAccessibility::IsEnabled(); +} + +SWIGEXPORT bool SWIGSTDCALL csharp_dali_accessibility_IsScreenReaderEnabled() +{ + return Dali::AtspiAccessibility::IsScreenReaderEnabled(); +} + +SWIGEXPORT void SWIGSTDCALL csharp_dali_accessibility_RegisterEnabledDisabledSignalHandler(void (*enabledSignalHandler)(), void (*disabledSignalHandler)()) +{ + using Dali::Accessibility::Bridge; + + if (!enabledSignalHandler) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Signal handler is null", NAMEOF(enabledSignalHandler)); + return; + } + + if (!disabledSignalHandler) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Signal handler is null", NAMEOF(disabledSignalHandler)); + return; + } + + Bridge::EnabledSignal().Connect(enabledSignalHandler); + Bridge::DisabledSignal().Connect(disabledSignalHandler); +} + +SWIGEXPORT void SWIGSTDCALL csharp_dali_accessibility_RegisterScreenReaderEnabledDisabledSignalHandler(void (*screenReaderEnabledSignalHandler)(), void (*screenReaderDisabledSignalHandler)()) +{ + using Dali::Accessibility::Bridge; + + if (!screenReaderEnabledSignalHandler) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Signal handler is null", NAMEOF(screenReaderEnabledSignalHandler)); + return; + } + + if (!screenReaderDisabledSignalHandler) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Signal handler is null", NAMEOF(screenReaderDisabledSignalHandler)); + return; + } + + Bridge::ScreenReaderEnabledSignal().Connect(screenReaderEnabledSignalHandler); + Bridge::ScreenReaderDisabledSignal().Connect(screenReaderDisabledSignalHandler); +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-adaptor/capture-wrap.cpp b/dali-csharp-binder/dali-adaptor/capture-wrap.cpp new file mode 100755 index 00000000..c1c7cc4b --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/capture-wrap.cpp @@ -0,0 +1,554 @@ +/* + * Copyright (c) 2020 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include +#include + +// INTERNAL INCLUDES +#include + +SWIGINTERN bool Dali_Capture_Signal_Empty(Dali::Capture::CaptureFinishedSignalType const* self) +{ + return self->Empty(); +} + +SWIGINTERN std::size_t Dali_Capture_Signal_GetConnectionCount(Dali::Capture::CaptureFinishedSignalType const* self) +{ + return self->GetConnectionCount(); +} + +SWIGINTERN void Dali_Capture_Signal_Connect(Dali::Capture::CaptureFinishedSignalType* self, void (*func)(Dali::Capture, Dali::Capture::FinishState)) +{ + self->Connect(func); +} + +SWIGINTERN void Dali_Capture_Signal_Disconnect(Dali::Capture::CaptureFinishedSignalType* self, void (*func)(Dali::Capture, Dali::Capture::FinishState)) +{ + self->Disconnect(func); +} + +SWIGINTERN void Dali_Capture_Signal_Emit(Dali::Capture::CaptureFinishedSignalType* self, Dali::Capture arg1, Dali::Capture::FinishState arg2) +{ + self->Emit(arg1, arg2); +} + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT Dali::BaseHandle* SWIGSTDCALL CSharp_Dali_Capture_Upcast(Dali::Capture* jarg1) +{ + return (Dali::BaseHandle*)jarg1; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Capture() +{ + void* jresult; + Dali::Capture* result = 0; + + { + try + { + result = (Dali::Capture*)new Dali::Capture(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Capture_New() +{ + void* jresult; + Dali::Capture result; + + { + try + { + result = Dali::Capture::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Capture((const Dali::Capture&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Capture_DownCast(void* jarg1) +{ + void* jresult; + Dali::BaseHandle arg1; + Dali::BaseHandle* argp1; + Dali::Capture 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::Capture::DownCast(arg1); + } + CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Capture((const Dali::Capture&)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Capture(void* jarg1) +{ + Dali::Capture* arg1 = (Dali::Capture*) 0; + + arg1 = (Dali::Capture*)jarg1; + { + try + { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Capture_New_With_CameraActor(void* jarg1) +{ + void* jresult; + Dali::CameraActor* arg1 = 0; + Dali::Capture result; + + arg1 = (Dali::CameraActor*)jarg1; + if (!arg1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor is null", 0); + return 0; + } + { + try + { + result = Dali::Capture::New(*arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Capture((const Dali::Capture&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Capture_Assign(void* jarg1, void* jarg2) +{ + void* jresult; + Dali::Capture* arg1 = (Dali::Capture*) 0; + Dali::Capture* arg2 = 0; + Dali::Capture* result = 0; + + arg1 = (Dali::Capture*)jarg1; + arg2 = (Dali::Capture*)jarg2; + + if (!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Capture const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Capture*) & (arg1)->operator =((Dali::Capture const&) * arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Capture_Start_1(void* nuiCapture, void* nuiSource, void* nuiSize, char* nuiPath, void* nuiClearColor) +{ + Dali::Capture* capture = (Dali::Capture*)0; + Dali::Actor* source = (Dali::Actor*)0; + Dali::Vector2* size = (Dali::Vector2*)0; + std::string* path; + std::string path_str(nuiPath); + Dali::Vector4* clearColor = (Dali::Vector4*)0; + + capture = (Dali::Capture*)nuiCapture; + source = (Dali::Actor*)nuiSource; + size = (Dali::Vector2*)nuiSize; + path = &path_str; + clearColor = (Dali::Vector4*)nuiClearColor; + + if (!capture || !source || !size || !path || !clearColor) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); + return; + } + + { + try + { + (capture)->Start(*source, (const Dali::Vector2&)*size, (const std::string&)*path, (const Dali::Vector4&) * clearColor); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Capture_Start_2(void* nuiCapture, void* nuiSource, void* nuiSize, char* nuiPath) +{ + Dali::Capture* capture = (Dali::Capture*)0; + Dali::Actor* source = (Dali::Actor*)0; + Dali::Vector2* size = (Dali::Vector2*)0; + std::string* path; + std::string path_str(nuiPath); + + capture = (Dali::Capture*)nuiCapture; + source = (Dali::Actor*)nuiSource; + size = (Dali::Vector2*)nuiSize; + path = &path_str; + + if (!capture || !source || !size || !path) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); + return; + } + + { + try + { + (capture)->Start(*source, (const Dali::Vector2&)*size, (const std::string&)*path); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Capture_Start_3(void* nuiCapture, void* nuiSource, void* nuiSize, char* nuiPath, void* nuiClearColor, uint32_t nuiQuality) +{ + Dali::Capture* capture = (Dali::Capture*)0; + Dali::Actor* source = (Dali::Actor*)0; + Dali::Vector2* size = (Dali::Vector2*)0; + std::string* path; + std::string path_str(nuiPath); + Dali::Vector4* clearColor = (Dali::Vector4*)0; + uint32_t quality; + + capture = (Dali::Capture*)nuiCapture; + source = (Dali::Actor*)nuiSource; + size = (Dali::Vector2*)nuiSize; + path = &path_str; + clearColor = (Dali::Vector4*)nuiClearColor; + quality = nuiQuality; + + if (!capture || !source || !size || !path || !clearColor) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); + return; + } + + { + try + { + (capture)->Start(*source, (const Dali::Vector2&)*size, (const std::string&)*path, (const Dali::Vector4&) * clearColor, quality); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Capture_Start_4( void* nuiCapture, void* nuiSource, void* nuiPosition, void* nuiSize, char* nuiPath, void* nuiClearColor ) +{ + Dali::Capture* capture = (Dali::Capture*)0; + Dali::Actor* source = (Dali::Actor*)0; + Dali::Vector2* position = (Dali::Vector2*)0; + Dali::Vector2* size = (Dali::Vector2*)0; + std::string* path; + std::string path_str(nuiPath); + Dali::Vector4* clearColor = (Dali::Vector4*)0; + + capture = (Dali::Capture*)nuiCapture; + source = (Dali::Actor*)nuiSource; + position = (Dali::Vector2*)nuiPosition; + size = (Dali::Vector2*)nuiSize; + path = &path_str; + clearColor = (Dali::Vector4*)nuiClearColor; + + if (!capture || !source || !size || !position || !path || !clearColor) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); + return; + } + + { + try + { + (capture)->Start(*source, (const Dali::Vector2&)*position, (const Dali::Vector2&)*size, (const std::string&)*path, (const Dali::Vector4&) * clearColor); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Capture_SetImageQuality( void* nuiCapture, uint32_t nuiQuality ) +{ + Dali::Capture* capture = (Dali::Capture*)0; + uint32_t quality = nuiQuality; + + capture = (Dali::Capture*)nuiCapture; + + if ( !capture ) + { + SWIG_CSharpSetPendingExceptionArgument( SWIG_CSharpArgumentNullException, "some argument is null", 0 ); + return; + } + + { + try + { + ( capture )->SetImageQuality( quality ); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Capture_Signal_Empty(void* jarg1) +{ + Dali::Capture::CaptureFinishedSignalType* arg1 = (Dali::Capture::CaptureFinishedSignalType*)jarg1; + bool result; + + { + try + { + result = Dali_Capture_Signal_Empty(arg1); + } + CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT std::size_t SWIGSTDCALL CSharp_Dali_Capture_Signal_GetConnectionCount(void* jarg1) +{ + Dali::Capture::CaptureFinishedSignalType* arg1 = (Dali::Capture::CaptureFinishedSignalType*)jarg1; + std::size_t result; + + { + try + { + result = Dali_Capture_Signal_GetConnectionCount((Dali::Capture::CaptureFinishedSignalType const*)arg1); + } + CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Capture_Signal_Connect(void* jarg1, void* jarg2) +{ + Dali::Capture::CaptureFinishedSignalType* arg1 = (Dali::Capture::CaptureFinishedSignalType*)jarg1; + void (*arg2)(Dali::Capture, Dali::Capture::FinishState) = (void (*)(Dali::Capture, Dali::Capture::FinishState))jarg2; + + { + try + { + Dali_Capture_Signal_Connect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Capture_Signal_Disconnect(void* jarg1, void* jarg2) +{ + Dali::Capture::CaptureFinishedSignalType* arg1 = (Dali::Capture::CaptureFinishedSignalType*)jarg1; + void (*arg2)(Dali::Capture, Dali::Capture::FinishState) = (void (*)(Dali::Capture, Dali::Capture::FinishState))jarg2; + + { + try + { + Dali_Capture_Signal_Disconnect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Capture_Signal_Emit(void* jarg1, void* jarg2, int jarg3) +{ + Dali::Capture::CaptureFinishedSignalType* arg1 = (Dali::Capture::CaptureFinishedSignalType*)jarg1; + Dali::Capture* arg2 = (Dali::Capture*)jarg2; + Dali::Capture::FinishState arg3; + + if (jarg3 == 0) + { + arg3 = Dali::Capture::FinishState::SUCCEEDED; + } + else { + arg3 = Dali::Capture::FinishState::FAILED; + } + + { + try + { + Dali_Capture_Signal_Emit(arg1, *arg2, arg3); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Capture_Signal() +{ + Dali::Capture::CaptureFinishedSignalType* result = 0; + + { + try + { + result = (Dali::Capture::CaptureFinishedSignalType*)new Dali::Capture::CaptureFinishedSignalType(); + } + CALL_CATCH_EXCEPTION(0); + } + return (void*)result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Capture_Signal(void* jarg1) +{ + Dali::Capture::CaptureFinishedSignalType* arg1 = (Dali::Capture::CaptureFinishedSignalType*)jarg1; + + { + try + { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Capture_Signal_Get(void* jarg1) +{ + Dali::Capture* arg1 = (Dali::Capture*)jarg1; + Dali::Capture::CaptureFinishedSignalType* result; + if (!arg1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); + return 0; + } + { + try + { + result = &(arg1->FinishedSignal()); + } + CALL_CATCH_EXCEPTION(0); + } + return (void*)result; +} + +struct NativeImageSourcePtrHandle +{ + Dali::NativeImageSourcePtr Ptr; +}; + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Capture_GetNativeImageSource(void* jarg1) +{ + Dali::Capture* arg1 = (Dali::Capture*)jarg1; + NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle(); + + if (!arg1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); + delete handle; + return 0; + } + { + try + { + handle->Ptr = arg1->GetNativeImageSource(); + } + catch (std::out_of_range &e) + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); + delete handle; + return 0; + } + catch (std::exception& e) + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); + delete handle; + return 0; + } + catch (Dali::DaliException e) + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); + delete handle; + return 0; + } + catch (...) + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); + delete handle; + return 0; + } + } + return (void*)handle; +} + +typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Capture_GenerateUrl(void* nuiCapture) +{ + Dali::Capture* capture = (Dali::Capture*)nuiCapture; + Dali::Toolkit::ImageUrl result; + void *jresult; + + if (!capture) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); + return 0; + } + { + try + { + result = Dali::Toolkit::Image::GenerateUrl(capture->GetNativeImageSource()); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result); + return jresult; +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Capture_GetCapturedBuffer(void *nuiCapture) +{ + Dali::Capture *capture = (Dali::Capture *)nuiCapture; + Dali::Devel::PixelBuffer pixelBuffer; + + if (!capture) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); + return 0; + } + { + try + { + pixelBuffer = Dali::DevelCapture::GetCapturedBuffer(*capture); + } + CALL_CATCH_EXCEPTION(0); + } + Dali::Devel::PixelBuffer *result = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)pixelBuffer); + return result; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-adaptor/component-application-wrap.cpp b/dali-csharp-binder/dali-adaptor/component-application-wrap.cpp new file mode 100644 index 00000000..2d6454be --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/component-application-wrap.cpp @@ -0,0 +1,209 @@ +/* + * Copyright (c) 2020 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + +int argC = 1; +char **argV = NULL; + +typedef void* (*CreateNativeSignalType)(); +CreateNativeSignalType callback; + +Dali::Any CreateNativeSignalCallbackWrapper() +{ + return callback(); +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ComponentApplication(int jarg1, char * jarg2, char * jarg3) { + void * jresult ; + int *arg1 = (int *) 0 ; + char ***arg2 ; + std::string *arg3 = 0 ; + Dali::ComponentApplication result; + { + int index = 0; + int length = 0; + char *retPtr; + char *nextPtr; + argC = jarg1; + argV = new char*[jarg1 + 1]; + + retPtr = strtok_r( jarg2, " ", &nextPtr); + if( retPtr ) + { + length = strlen(retPtr); + } + argV[index] = new char[length + 1]; + if( retPtr ) + { + strncpy(argV[index], retPtr, length); + } + argV[index][length] = '\0'; + index++; + + while (index < jarg1) + { + length = 0; + retPtr = strtok_r(NULL, " ", &nextPtr); + if( retPtr ) + { + length = strlen(retPtr); + } + argV[index] = new char[length + 1]; + if( retPtr ) + { + strncpy(argV[index], retPtr, length); + } + argV[index][length] = '\0'; + index++; + } + + argV[jarg1] = NULL; + argC = jarg1; + + arg1 = &argC; + arg2 = &argV; + } + + if (!jarg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg3_str(jarg3); + arg3 = &arg3_str; + { + try { + result = Dali::ComponentApplication::New(arg1,arg2,(std::string const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::ComponentApplication((const Dali::ComponentApplication &)result); + + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ComponentApplication_SWIG1(void * jarg1) { + void * jresult ; + Dali::ComponentApplication *arg1 = 0 ; + Dali::ComponentApplication *result = 0 ; + + arg1 = (Dali::ComponentApplication *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ComponentApplication const & type is null", 0); + return 0; + } + { + try { + result = (Dali::ComponentApplication *)new Dali::ComponentApplication((Dali::ComponentApplication const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_assign_ComponentApplication(void * jarg1, void * jarg2) { + void * jresult ; + Dali::ComponentApplication *arg1 = (Dali::ComponentApplication *) 0 ; + Dali::ComponentApplication *arg2 = 0 ; + Dali::ComponentApplication *result = 0 ; + + arg1 = (Dali::ComponentApplication *)jarg1; + arg2 = (Dali::ComponentApplication *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ComponentApplication const & type is null", 0); + return 0; + } + { + try { + result = (Dali::ComponentApplication *) &(arg1)->operator =((Dali::ComponentApplication const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ComponentApplication(void * jarg1) { + Dali::ComponentApplication *arg1 = (Dali::ComponentApplication *) 0 ; + + arg1 = (Dali::ComponentApplication *)jarg1; + { + try { + delete arg1; + if( argV ) + { + // free string data + for( int i=0; i < argC+1; i++) + { + delete [] argV[i]; + } + delete [] argV; + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_ComponentApplication_CreateNativeSignal(void * jarg1) { + void* jresult ; + Dali::ComponentApplication *arg1 = (Dali::ComponentApplication *) 0 ; + Dali::ComponentApplication::CreateSignalType *result = 0 ; + + arg1 = (Dali::ComponentApplication *)jarg1; + { + try { + result = (Dali::ComponentApplication::CreateSignalType *) &(arg1)->CreateSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ComponentApplication_CreateNativeSignal_Connect(void * jarg1, void * jarg2) { + Dali::ComponentApplication *arg1 = (Dali::ComponentApplication *) 0 ; + arg1 = (Dali::ComponentApplication *)jarg1; + + callback = (CreateNativeSignalType) jarg2; + { + try { + (arg1)->CreateSignal().Connect(CreateNativeSignalCallbackWrapper); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ComponentApplication_CreateNativeSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::ComponentApplication *arg1 = (Dali::ComponentApplication *) 0 ; + arg1 = (Dali::ComponentApplication *)jarg1; + + { + try { + (arg1)->CreateSignal().Disconnect(CreateNativeSignalCallbackWrapper); + } CALL_CATCH_EXCEPTION(); + } +} +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/dali-adaptor/dali-adaptor-wrap.cpp b/dali-csharp-binder/dali-adaptor/dali-adaptor-wrap.cpp new file mode 100644 index 00000000..1ca4b03f --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/dali-adaptor-wrap.cpp @@ -0,0 +1,2116 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include +#include +#include + +// INTERNAL INCLUDES +#include + +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +// SWIGINTERN - the relevant parts of the generated code can be seen the below. + +SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()) +{ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()) +{ + self->Disconnect( func ); +} +SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self) +{ + return self->Emit(); +} + +using namespace Dali; + +// keep argWidgetCs and argWidgetV so they're always available to DALi +int argWidgetC = 1; +char **argWidgetV = NULL; + + +#ifdef __cplusplus +extern "C" { +#endif + + +// Method + + +// WindowSystem + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetScreenSize() { + void * jresult ; + int width, height; + + try { + Dali::DevelWindowSystem::GetScreenSize(width, height); + } CALL_CATCH_EXCEPTION(0); + + jresult = new Dali::Size(width, height); + return jresult; +} + + +// Timer + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() { + void * jresult ; + Dali::Timer *result = 0 ; + + { + try { + result = (Dali::Timer *)new Dali::Timer(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) { + void * jresult ; + unsigned int arg1 ; + Dali::Timer result; + + arg1 = (unsigned int)jarg1; + { + try { + result = Dali::Timer::New(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Timer((const Dali::Timer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Timer *arg1 = 0 ; + Dali::Timer *result = 0 ; + + arg1 = (Dali::Timer *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Timer *arg1 = (Dali::Timer *) 0 ; + Dali::Timer *arg2 = 0 ; + Dali::Timer *result = 0 ; + + arg1 = (Dali::Timer *)jarg1; + arg2 = (Dali::Timer *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) { + Dali::Timer *arg1 = (Dali::Timer *) 0 ; + + arg1 = (Dali::Timer *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Timer 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::Timer::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Timer((const Dali::Timer &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) { + Dali::Timer *arg1 = (Dali::Timer *) 0 ; + + arg1 = (Dali::Timer *)jarg1; + { + try { + (arg1)->Start(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) { + Dali::Timer *arg1 = (Dali::Timer *) 0 ; + + arg1 = (Dali::Timer *)jarg1; + { + try { + (arg1)->Stop(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) { + Dali::Timer *arg1 = (Dali::Timer *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Timer *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + (arg1)->SetInterval(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) { + unsigned int jresult ; + Dali::Timer *arg1 = (Dali::Timer *) 0 ; + unsigned int result; + + arg1 = (Dali::Timer *)jarg1; + { + try { + result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) { + bool jresult ; + Dali::Timer *arg1 = (Dali::Timer *) 0 ; + bool result; + + arg1 = (Dali::Timer *)jarg1; + { + try { + result = (bool)((Dali::Timer const *)arg1)->IsRunning(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) { + void * jresult ; + Dali::Timer *arg1 = (Dali::Timer *) 0 ; + Dali::Timer::TimerSignalType *result = 0 ; + + arg1 = (Dali::Timer *)jarg1; + { + try { + result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ; + bool result; + + arg1 = (Dali::Signal< bool () > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< bool () > *)jarg1; + { + try { + result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) { + Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ; + bool (*arg2)() = (bool (*)()) 0 ; + + arg1 = (Dali::Signal< bool () > *)jarg1; + arg2 = (bool (*)())jarg2; + { + try { + Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ; + bool (*arg2)() = (bool (*)()) 0 ; + + arg1 = (Dali::Signal< bool () > *)jarg1; + arg2 = (bool (*)())jarg2; + { + try { + Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) { + bool jresult ; + Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ; + bool result; + + arg1 = (Dali::Signal< bool () > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() { + void * jresult ; + Dali::Signal< bool () > *result = 0 ; + + { + try { + result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) { + Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ; + + arg1 = (Dali::Signal< bool () > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +// PixelBuffer + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) { + void * jresult ; + unsigned int arg1 ; + unsigned int arg2 ; + Dali::Pixel::Format arg3 ; + Dali::Devel::PixelBuffer result; + + arg1 = (unsigned int)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (Dali::Pixel::Format)jarg3; + { + try { + result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() { + void * jresult ; + Dali::Devel::PixelBuffer *result = 0 ; + + { + try { + result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) { + Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; + + arg1 = (Dali::Devel::PixelBuffer *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Devel::PixelBuffer *arg1 = 0 ; + Dali::Devel::PixelBuffer *result = 0 ; + + arg1 = (Dali::Devel::PixelBuffer *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; + Dali::Devel::PixelBuffer *arg2 = 0 ; + Dali::Devel::PixelBuffer *result = 0 ; + + arg1 = (Dali::Devel::PixelBuffer *)jarg1; + arg2 = (Dali::Devel::PixelBuffer *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) { + void * jresult ; + Dali::Devel::PixelBuffer *arg1 = 0 ; + Dali::PixelData result; + + arg1 = (Dali::Devel::PixelBuffer *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0); + return 0; + } + { + try { + result = Dali::Devel::PixelBuffer::Convert(*arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::PixelData((const Dali::PixelData &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) { + void * jresult ; + Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; + Dali::PixelData result; + + arg1 = (Dali::Devel::PixelBuffer *)jarg1; + { + try { + result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::PixelData((const Dali::PixelData &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) { + void * jresult ; + Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; + unsigned char *result = 0 ; + + arg1 = (Dali::Devel::PixelBuffer *)jarg1; + { + try { + result = (unsigned char *)(arg1)->GetBuffer(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) { + unsigned int jresult ; + Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; + unsigned int result; + + arg1 = (Dali::Devel::PixelBuffer *)jarg1; + { + try { + result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) { + unsigned int jresult ; + Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; + unsigned int result; + + arg1 = (Dali::Devel::PixelBuffer *)jarg1; + { + try { + result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) { + int jresult ; + Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; + Dali::Pixel::Format result; + + arg1 = (Dali::Devel::PixelBuffer *)jarg1; + { + try { + result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, bool jarg4) { + Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; + Dali::Devel::PixelBuffer arg2 ; + float arg3 ; + bool arg4 ; + Dali::Devel::PixelBuffer *argp2 ; + + arg1 = (Dali::Devel::PixelBuffer *)jarg1; + argp2 = (Dali::Devel::PixelBuffer *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0); + return ; + } + arg2 = *argp2; + arg3 = (float)jarg3; + arg4 = jarg4 ? true : false; + { + try { + (arg1)->ApplyMask(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) { + Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; + Dali::Devel::PixelBuffer arg2 ; + float arg3 ; + Dali::Devel::PixelBuffer *argp2 ; + + arg1 = (Dali::Devel::PixelBuffer *)jarg1; + argp2 = (Dali::Devel::PixelBuffer *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0); + return ; + } + arg2 = *argp2; + arg3 = (float)jarg3; + { + try { + (arg1)->ApplyMask(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) { + Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; + Dali::Devel::PixelBuffer arg2 ; + Dali::Devel::PixelBuffer *argp2 ; + + arg1 = (Dali::Devel::PixelBuffer *)jarg1; + argp2 = (Dali::Devel::PixelBuffer *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->ApplyMask(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) { + Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; + float arg2 ; + + arg1 = (Dali::Devel::PixelBuffer *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->ApplyGaussianBlur(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) { + Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; + uint16_t arg2 ; + uint16_t arg3 ; + uint16_t arg4 ; + uint16_t arg5 ; + + arg1 = (Dali::Devel::PixelBuffer *)jarg1; + arg2 = (uint16_t)jarg2; + arg3 = (uint16_t)jarg3; + arg4 = (uint16_t)jarg4; + arg5 = (uint16_t)jarg5; + { + try { + (arg1)->Crop(arg2,arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) { + Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; + uint16_t arg2 ; + uint16_t arg3 ; + + arg1 = (Dali::Devel::PixelBuffer *)jarg1; + arg2 = (uint16_t)jarg2; + arg3 = (uint16_t)jarg3; + { + try { + (arg1)->Resize(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void* jarg2) { + Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; + Dali::Degree * arg2 ; + + bool result = false; + + arg1 = (Dali::Devel::PixelBuffer *)jarg1; + arg2 = (Dali::Degree *)jarg2; + { + try { + result = (arg1)->Rotate(*arg2); + } CALL_CATCH_EXCEPTION(false); + } + return result; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBrightness(void * jarg1) { + Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; + uint32_t result = 0; + + arg1 = (Dali::Devel::PixelBuffer *)jarg1; + { + try { + result = (arg1)->GetBrightness(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::ImageDimensions arg2 ; + Dali::FittingMode::Type arg3 ; + Dali::SamplingMode::Type arg4 ; + bool arg5 ; + Dali::ImageDimensions *argp2 ; + Dali::Devel::PixelBuffer result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + argp2 = (Dali::ImageDimensions *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg2 = *argp2; + arg3 = (Dali::FittingMode::Type)jarg3; + arg4 = (Dali::SamplingMode::Type)jarg4; + arg5 = jarg5 ? true : false; + { + try { + result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::ImageDimensions arg2 ; + Dali::FittingMode::Type arg3 ; + Dali::SamplingMode::Type arg4 ; + Dali::ImageDimensions *argp2 ; + Dali::Devel::PixelBuffer result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + argp2 = (Dali::ImageDimensions *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg2 = *argp2; + arg3 = (Dali::FittingMode::Type)jarg3; + arg4 = (Dali::SamplingMode::Type)jarg4; + { + try { + result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::ImageDimensions arg2 ; + Dali::FittingMode::Type arg3 ; + Dali::ImageDimensions *argp2 ; + Dali::Devel::PixelBuffer result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + argp2 = (Dali::ImageDimensions *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg2 = *argp2; + arg3 = (Dali::FittingMode::Type)jarg3; + { + try { + result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::ImageDimensions arg2 ; + Dali::ImageDimensions *argp2 ; + Dali::Devel::PixelBuffer result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + argp2 = (Dali::ImageDimensions *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::Devel::PixelBuffer result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + { + try { + result = Dali::LoadImageFromFile((std::string const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_0(void * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) { + void * jresult ; + Dali::Vector *arg1 = (Dali::Vector *) 0; + Dali::ImageDimensions arg2 ; + Dali::FittingMode::Type arg3 ; + Dali::SamplingMode::Type arg4 ; + bool arg5 ; + Dali::ImageDimensions *argp2 ; + Dali::Devel::PixelBuffer result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0); + return 0; + } + arg1 = (Dali::Vector *)jarg1; + argp2 = (Dali::ImageDimensions *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg2 = *argp2; + arg3 = (Dali::FittingMode::Type)jarg3; + arg4 = (Dali::SamplingMode::Type)jarg4; + arg5 = jarg5 ? true : false; + { + try { + result = Dali::LoadImageFromBuffer((const Dali::Vector&)*arg1, arg2, arg3, arg4, arg5); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_1(void * jarg1, void * jarg2, int jarg3, int jarg4) { + void * jresult ; + Dali::Vector *arg1 = (Dali::Vector *) 0; + Dali::ImageDimensions arg2 ; + Dali::FittingMode::Type arg3 ; + Dali::SamplingMode::Type arg4 ; + Dali::ImageDimensions *argp2 ; + Dali::Devel::PixelBuffer result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0); + return 0; + } + arg1 = (Dali::Vector *)jarg1; + argp2 = (Dali::ImageDimensions *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg2 = *argp2; + arg3 = (Dali::FittingMode::Type)jarg3; + arg4 = (Dali::SamplingMode::Type)jarg4; + { + try { + result = Dali::LoadImageFromBuffer((const Dali::Vector&)*arg1, arg2, arg3, arg4); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_2(void * jarg1, void * jarg2, int jarg3) { + void * jresult ; + Dali::Vector *arg1 = (Dali::Vector *) 0; + Dali::ImageDimensions arg2 ; + Dali::FittingMode::Type arg3 ; + Dali::ImageDimensions *argp2 ; + Dali::Devel::PixelBuffer result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0); + return 0; + } + arg1 = (Dali::Vector *)jarg1; + argp2 = (Dali::ImageDimensions *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg2 = *argp2; + arg3 = (Dali::FittingMode::Type)jarg3; + { + try { + result = Dali::LoadImageFromBuffer((const Dali::Vector&)*arg1, arg2, arg3); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_3(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector *arg1 = (Dali::Vector *) 0; + Dali::ImageDimensions arg2 ; + Dali::ImageDimensions *argp2 ; + Dali::Devel::PixelBuffer result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0); + return 0; + } + arg1 = (Dali::Vector *)jarg1; + argp2 = (Dali::ImageDimensions *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = Dali::LoadImageFromBuffer((const Dali::Vector&)*arg1, arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_4(void * jarg1) { + void * jresult ; + Dali::Vector *arg1 = (Dali::Vector *) 0; + Dali::Devel::PixelBuffer result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0); + return 0; + } + arg1 = (Dali::Vector *)jarg1; + { + try { + result = Dali::LoadImageFromBuffer((const Dali::Vector&)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::ImageDimensions arg2 ; + Dali::FittingMode::Type arg3 ; + Dali::SamplingMode::Type arg4 ; + bool arg5 ; + Dali::ImageDimensions *argp2 ; + Dali::Devel::PixelBuffer result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + argp2 = (Dali::ImageDimensions *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg2 = *argp2; + arg3 = (Dali::FittingMode::Type)jarg3; + arg4 = (Dali::SamplingMode::Type)jarg4; + arg5 = jarg5 ? true : false; + { + try { + result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::ImageDimensions arg2 ; + Dali::FittingMode::Type arg3 ; + Dali::SamplingMode::Type arg4 ; + Dali::ImageDimensions *argp2 ; + Dali::Devel::PixelBuffer result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + argp2 = (Dali::ImageDimensions *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg2 = *argp2; + arg3 = (Dali::FittingMode::Type)jarg3; + arg4 = (Dali::SamplingMode::Type)jarg4; + { + try { + result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::ImageDimensions arg2 ; + Dali::FittingMode::Type arg3 ; + Dali::ImageDimensions *argp2 ; + Dali::Devel::PixelBuffer result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + argp2 = (Dali::ImageDimensions *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg2 = *argp2; + arg3 = (Dali::FittingMode::Type)jarg3; + { + try { + result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::ImageDimensions arg2 ; + Dali::ImageDimensions *argp2 ; + Dali::Devel::PixelBuffer result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + argp2 = (Dali::ImageDimensions *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::Devel::PixelBuffer result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + { + try { + result = Dali::DownloadImageSynchronously((std::string const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1, bool jarg2) { + void * jresult ; + std::string *arg1 = 0 ; + bool arg2 ; + Dali::ImageDimensions result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + arg2 = jarg2 ? true : false; + { + try { + result = Dali::GetOriginalImageSize((std::string const &)*arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::ImageDimensions arg2 ; + Dali::FittingMode::Type arg3 ; + Dali::SamplingMode::Type arg4 ; + bool arg5 ; + Dali::ImageDimensions *argp2 ; + Dali::ImageDimensions result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + argp2 = (Dali::ImageDimensions *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg2 = *argp2; + arg3 = (Dali::FittingMode::Type)jarg3; + arg4 = (Dali::SamplingMode::Type)jarg4; + arg5 = jarg5 ? true : false; + { + try { + result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::ImageDimensions arg2 ; + Dali::FittingMode::Type arg3 ; + Dali::SamplingMode::Type arg4 ; + Dali::ImageDimensions *argp2 ; + Dali::ImageDimensions result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + argp2 = (Dali::ImageDimensions *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg2 = *argp2; + arg3 = (Dali::FittingMode::Type)jarg3; + arg4 = (Dali::SamplingMode::Type)jarg4; + { + try { + result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::ImageDimensions arg2 ; + Dali::FittingMode::Type arg3 ; + Dali::ImageDimensions *argp2 ; + Dali::ImageDimensions result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + argp2 = (Dali::ImageDimensions *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg2 = *argp2; + arg3 = (Dali::FittingMode::Type)jarg3; + { + try { + result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::ImageDimensions arg2 ; + Dali::ImageDimensions *argp2 ; + Dali::ImageDimensions result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + argp2 = (Dali::ImageDimensions *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::ImageDimensions result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + { + try { + result = Dali::GetClosestImageSize((std::string const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result); + return jresult; +} + + +// NativeImageSource + +struct NativeImageSourcePtrHandle +{ + NativeImageSourcePtr Ptr; +}; + +SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1) +{ + NativeImageSource* arg1 = (NativeImageSource*)jarg1; + return (NativeImageInterface*)(arg1); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3) +{ + void* jresult; + NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle(); + { + try { + handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) ); + } + catch (std::out_of_range & e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } + catch (std::exception & e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } + catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } + catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)handle; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1) +{ + void* jresult; + NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1; + jresult = (void*)( handle->Ptr.Get() ); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) { + NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1; + { + try { + delete arg1; + } + catch (std::out_of_range & e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return; + }; + } + catch (std::exception & e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return; + }; + } + catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return; + }; + } + catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return; + }; + } + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4) +{ + void* jresult; + NativeImageSource* arg1 = (NativeImageSource*)jarg1; + uint32_t* arg2 = (uint32_t*)(jarg2); + uint32_t* arg3 = (uint32_t*)(jarg3); + uint32_t* arg4 = (uint32_t*)(jarg4); + { + try { + jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 ); + } + catch (std::out_of_range & e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } + catch (std::exception & e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } + catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } + catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + return jresult; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1) +{ + bool jresult; + NativeImageSource* arg1 = (NativeImageSource*)jarg1; + + { + try { + jresult = Dali::DevelNativeImageSource::ReleaseBuffer(*arg1, Rect{}); + } + catch (std::out_of_range & e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } + catch (std::exception & e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } + catch (Dali::DaliException e) { + { + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } + catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_EnableBackBuffer(void* nativeImageHandle, bool enable) +{ + NativeImageSource* nativeImage = static_cast(nativeImageHandle); + + if(!nativeImage) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "nativeImageHandle is null", 0); + return; + } + { + try + { + Dali::DevelNativeImageSource::EnableBackBuffer(*nativeImage, enable); + } + CALL_CATCH_EXCEPTION(); + } +} + + +/* + * Widget binding + */ +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) { + return (Dali::BaseObject *)jarg1; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() { + void * jresult ; + Dali::Widget result; + + { + try { + result = Dali::Widget::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Widget((const Dali::Widget &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Internal::Adaptor::Widget *arg1 = 0 ; + Dali::Widget result; + + arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; + + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0); + return 0; + } + { + try { + jresult = new Dali::Widget(arg1); + } CALL_CATCH_EXCEPTION(0); + } + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() { + void * jresult ; + Dali::Widget *result = 0 ; + + { + try { + result = (Dali::Widget *)new Dali::Widget(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Widget *arg1 = (Dali::Widget *) 0 ; + Dali::Widget *arg2 = 0 ; + Dali::Widget *result = 0 ; + + arg1 = (Dali::Widget *)jarg1; + arg2 = (Dali::Widget *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) { + Dali::Widget *arg1 = (Dali::Widget *) 0 ; + + arg1 = (Dali::Widget *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) { + Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; + std::string *arg2 = 0 ; + Dali::Window arg3 ; + Dali::Window *argp3 ; + + arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + argp3 = (Dali::Window *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + arg3 = *argp3; + { + try { + (arg1)->OnCreate((std::string const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) { + Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; + std::string *arg2 = 0 ; + Dali::Window arg3 ; + Dali::Window *argp3 ; + + arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + argp3 = (Dali::Window *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + arg3 = *argp3; + { + try { + (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) { + Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; + std::string *arg2 = 0 ; + Dali::Widget::Termination arg3 ; + + arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Widget::Termination)jarg3; + { + try { + (arg1)->OnTerminate((std::string const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) { + Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; + std::string *arg2 = 0 ; + Dali::Widget::Termination arg3 ; + + arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Widget::Termination)jarg3; + { + try { + (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) { + Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; + + arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; + { + try { + (arg1)->OnPause(); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) { + Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; + + arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; + { + try { + (arg1)->Dali::Internal::Adaptor::Widget::OnPause(); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) { + Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; + + arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; + { + try { + (arg1)->OnResume(); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) { + Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; + + arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; + { + try { + (arg1)->Dali::Internal::Adaptor::Widget::OnResume(); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) { + Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; + Dali::Window arg2 ; + Dali::Window *argp2 ; + + arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; + argp2 = (Dali::Window *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->OnResize(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) { + Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; + Dali::Window arg2 ; + Dali::Window *argp2 ; + + arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; + argp2 = (Dali::Window *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) { + Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; + std::string *arg2 = 0 ; + int arg3 ; + + arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (int)jarg3; + { + try { + (arg1)->OnUpdate((std::string const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) { + Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; + std::string *arg2 = 0 ; + int arg3 ; + + arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (int)jarg3; + { + try { + (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) { + Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; + Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; + Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; + + arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; + arg2 = (Dali::SlotObserver *)jarg2; + arg3 = (Dali::CallbackBase *)jarg3; + { + try { + (arg1)->SignalConnected(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) { + Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; + Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; + Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; + + arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; + arg2 = (Dali::SlotObserver *)jarg2; + arg3 = (Dali::CallbackBase *)jarg3; + { + try { + (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) { + Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; + Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; + Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; + + arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; + arg2 = (Dali::SlotObserver *)jarg2; + arg3 = (Dali::CallbackBase *)jarg3; + { + try { + (arg1)->SignalDisconnected(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) { + Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; + Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; + Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; + + arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; + arg2 = (Dali::SlotObserver *)jarg2; + arg3 = (Dali::CallbackBase *)jarg3; + { + try { + (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) { + Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + (arg1)->SetContentInfo((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetUsingKeyEvent(void * jwidget, bool jflag) { + Dali::Internal::Adaptor::Widget *widget = (Dali::Internal::Adaptor::Widget *) 0 ; + bool flag; + + widget = (Dali::Internal::Adaptor::Widget *)jwidget; + flag = jflag ? true : false; + { + try { + (widget)->SetUsingKeyEvent(flag); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) { + Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; + Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ; + + arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; + arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2; + { + try { + (arg1)->SetImpl(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) { + void * jresult ; + int *arg1 = (int *) 0 ; + char ***arg2 ; + std::string *arg3 = 0 ; + Dali::WidgetApplication result; + { + int index = 0; + int length = 0; + char *retPtr; + char *nextPtr; + argWidgetC = jarg1; + argWidgetV = new char*[jarg1 + 1]; + + retPtr = strtok_r( jarg2, " ", &nextPtr); + if( retPtr ) + { + length = strlen(retPtr); + } + argWidgetV[index] = new char[length + 1]; + if( retPtr ) + { + strncpy(argWidgetV[index], retPtr, length); + } + argWidgetV[index][length] = '\0'; + index++; + + while (index < jarg1) + { + length = 0; + retPtr = strtok_r(NULL, " ", &nextPtr); + if( retPtr ) + { + length = strlen(retPtr); + } + argWidgetV[index] = new char[length + 1]; + if( retPtr ) + { + strncpy(argWidgetV[index], retPtr, length); + } + argWidgetV[index][length] = '\0'; + index++; + } + + argWidgetV[jarg1] = NULL; + argWidgetC = jarg1; + + arg1 = &argWidgetC; + arg2 = &argWidgetV; + } + + if (!jarg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg3_str(jarg3); + arg3 = &arg3_str; + { + try { + result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() { + void * jresult ; + Dali::WidgetApplication *result = 0 ; + + { + try { + result = (Dali::WidgetApplication *)new Dali::WidgetApplication(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) { + void * jresult ; + Dali::WidgetApplication *arg1 = 0 ; + Dali::WidgetApplication *result = 0 ; + + arg1 = (Dali::WidgetApplication *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0); + return 0; + } + { + try { + result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ; + Dali::WidgetApplication *arg2 = 0 ; + Dali::WidgetApplication *result = 0 ; + + arg1 = (Dali::WidgetApplication *)jarg1; + arg2 = (Dali::WidgetApplication *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0); + return 0; + } + { + try { + result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) { + Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ; + + arg1 = (Dali::WidgetApplication *)jarg1; + { + try { + delete arg1; + if( argWidgetV ) + { + // free string data + for( int i=0; i < argWidgetC+1; i++) + { + delete [] argWidgetV[i]; + } + delete [] argWidgetV; + } + } CALL_CATCH_EXCEPTION(); + } +} + + +typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&); +CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL; + +static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName ) +{ + Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() ); + return *widget; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) { + Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::WidgetApplication *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(*jarg2); + arg2 = &arg2_str; + + if(!_CSharpCreateWidgetFunction) + { + _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3; + } + + { + try { + (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction); + } CALL_CATCH_EXCEPTION(); + } + *jarg2 = SWIG_csharp_string_callback(arg2->c_str()); +} + + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-adaptor/drag-and-drop-wrap.cpp b/dali-csharp-binder/dali-adaptor/drag-and-drop-wrap.cpp new file mode 100644 index 00000000..4589ada0 --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/drag-and-drop-wrap.cpp @@ -0,0 +1,252 @@ +/* + * Copyright (c) 2022 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#define SWIGSTDCALL + +// INCLUDES +#include +#include +#include + +using namespace Dali; + +/* Callback for returning strings to C# without leaking memory */ +typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +static char mimeTypeEmptyMsg[] = "Mime Type is Empty!"; +static char dataEmptyMsg[] = "Data is Empty!"; +static const char * nullExceptMsg = "Attempt to dereference null Dali::Adaptor::DragAndDrop"; + +using DnDCallback = void(SWIGSTDCALL *)(const Dali::DragAndDrop::DragEvent&); +DnDCallback dndCallback; + +using SourceCallback = void(SWIGSTDCALL *)(enum Dali::DragAndDrop::SourceEventType); +SourceCallback sourceCallback; + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_DragAndDrop_New__SWIG_0() { + void *jresult = nullptr; + Dali::DragAndDrop result; + try { + result = Dali::DragAndDrop::Get(); + jresult = new Dali::DragAndDrop((const Dali::DragAndDrop &)result); + + } CALL_CATCH_EXCEPTION(0); + + return jresult; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_DragAndDrop_StartDragAndDrop(void * argDnD, void * argSource, void * argShadowWindow, void * argMimeType, char * argData, void * argSourceCallback) { + Dali::DragAndDrop *dnd = (Dali::DragAndDrop *)argDnD; + + if (!dnd) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return false; + } + + Dali::Actor *pSource; + Dali::Window *pShadow; + Dali::Actor source; + Dali::Window shadow; + + pSource = (Dali::Actor *)argSource; + if (!pSource) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return false; + } + + pShadow = (Dali::Window *)argShadowWindow; + if (!pShadow) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return false; + } + + source = *pSource; + shadow = *pShadow; + + Dali::DragAndDrop::DragData dragData; + dragData.SetMimeType((const char*)argMimeType); + dragData.SetData(argData); + + bool result = false; + { + try { + sourceCallback = (SourceCallback)argSourceCallback; + result = dnd->StartDragAndDrop(source, shadow, dragData, sourceCallback); + } + CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_DragAndDrop_AddListener(void * jarg1, void * jarg2, void * jarg3) { + Dali::DragAndDrop *dnd = (Dali::DragAndDrop *)jarg1; + if (!dnd) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return false; + } + + Dali::Actor *argp2; + Dali::Actor target; + + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return false; + } + + target = *argp2; + bool result = false; + { + try { + dndCallback = (DnDCallback)jarg3; + result = dnd->AddListener(target, dndCallback); + } + CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_DragAndDrop_RemoveListener(void * argDnD, void * argTarget, void * argCallback) { + Dali::DragAndDrop *dnd = (Dali::DragAndDrop *)argDnD; + if (!dnd) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return false; + } + + Dali::Actor *pTarget; + Dali::Actor target; + + pTarget = (Dali::Actor *)argTarget; + if (!pTarget) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return false; + } + + target = *pTarget; + bool result = false; + { + try { + //TODO: use argCallback to remove target listener + result = dnd->RemoveListener(target); + } + CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DragEvent_GetAction(void * jarg) { + int jresult; + Dali::DragAndDrop::DragEvent *dragEvent = (Dali::DragAndDrop::DragEvent *)jarg; + + if (!dragEvent) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return 0; + } + { + try { + jresult = (int)((Dali::DragAndDrop::DragEvent &)*dragEvent).GetAction(); + } + CALL_CATCH_EXCEPTION(0); + } + + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragEvent_GetPosition(void * jarg) { + void * jresult = nullptr; + Dali::DragAndDrop::DragEvent *dragEvent = (Dali::DragAndDrop::DragEvent *)jarg; + Dali::Vector2 result; + + if (!dragEvent) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return 0; + } + { + try { + result = ((Dali::DragAndDrop::DragEvent &)*dragEvent).GetPosition(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragEvent_GetMimeType(void * argDragEvent) { + char * jresult = nullptr; + Dali::DragAndDrop::DragEvent *dragEvent = (Dali::DragAndDrop::DragEvent *)argDragEvent; + std::string result; + + if (!dragEvent) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return 0; + } + { + try { + const char* mimeType = ((Dali::DragAndDrop::DragEvent &)*dragEvent).GetMimeType(); + if (mimeType != nullptr) + { + result = mimeType; + } + else + { + result = mimeTypeEmptyMsg; + } + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback((&result)->c_str()); + return jresult; +} + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragEvent_GetData(void * argDragEvent) { + char * jresult = nullptr; + Dali::DragAndDrop::DragEvent *dragEvent = (Dali::DragAndDrop::DragEvent *)argDragEvent; + std::string result; + + if (!dragEvent) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return 0; + } + { + try { + const char* data = ((Dali::DragAndDrop::DragEvent &)*dragEvent).GetData(); + if (data != nullptr) + { + result = data; + } + else + { + result = dataEmptyMsg; + } + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback((&result)->c_str()); + return jresult; +} + +#ifdef __cplusplus +} // end extern "C" +#endif diff --git a/dali-csharp-binder/dali-adaptor/encoded-image-buffer-wrap.cpp b/dali-csharp-binder/dali-adaptor/encoded-image-buffer-wrap.cpp new file mode 100755 index 00000000..00872fcb --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/encoded-image-buffer-wrap.cpp @@ -0,0 +1,155 @@ +/* + * Copyright (c) 2021 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_EncodedImageBuffer__SWIG_0() +{ + void *jresult; + Dali::EncodedImageBuffer *result = 0; + + { + try + { + result = new Dali::EncodedImageBuffer(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_EncodedImageBuffer__SWIG_1(void *nuiEncodedImageBuffer) +{ + void *jresult; + Dali::EncodedImageBuffer *result = (Dali::EncodedImageBuffer *)0; + Dali::EncodedImageBuffer *encodedImageBuffer = (Dali::EncodedImageBuffer *)nuiEncodedImageBuffer;; + + if (!encodedImageBuffer) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedImageBuffer const & type is null", 0); + return 0; + } + { + try + { + result = new Dali::EncodedImageBuffer((Dali::EncodedImageBuffer const &)*encodedImageBuffer); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +// note: nuiRawBuffer is same as Dali::Vector, which created by CSharp_Dali_new_VectorUnsignedChar__SWIG_0 +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_EncodedImageBuffer_New(void *nuiRawBuffer) +{ + void *jresult; + Dali::EncodedImageBuffer::RawBufferType *buffer = (Dali::EncodedImageBuffer::RawBufferType *)nuiRawBuffer; + Dali::EncodedImageBuffer result; + + if (!buffer) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0); + return 0; + } + { + try + { + result = Dali::EncodedImageBuffer::New((const Dali::EncodedImageBuffer::RawBufferType &)*buffer); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::EncodedImageBuffer((const Dali::EncodedImageBuffer &)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedImageBuffer(void *nuiEncodedImageBuffer) +{ + Dali::EncodedImageBuffer *encodedImageBuffer = (Dali::EncodedImageBuffer *)nuiEncodedImageBuffer;; + { + try + { + delete encodedImageBuffer; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_EncodedImageBuffer_GetRawBuffer(void *nuiEncodedImageBuffer) +{ + void *jresult; + Dali::EncodedImageBuffer::RawBufferType *result = (Dali::EncodedImageBuffer::RawBufferType *)0; + Dali::EncodedImageBuffer *encodedImageBuffer = (Dali::EncodedImageBuffer *)nuiEncodedImageBuffer;; + + if (!encodedImageBuffer) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedImageBuffer const & type is null", 0); + return 0; + } + { + try + { + result = const_cast(&(encodedImageBuffer->GetRawBuffer())); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_EncodedImageBuffer_GenerateUrl(void *nuiEncodedImageBuffer) +{ + void *jresult; + Dali::Toolkit::ImageUrl result; + Dali::EncodedImageBuffer *encodedImageBuffer = (Dali::EncodedImageBuffer *)nuiEncodedImageBuffer;; + + if (!encodedImageBuffer) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedImageBuffer const & type is null", 0); + return 0; + } + { + try + { + result = Dali::Toolkit::Image::GenerateUrl((const Dali::EncodedImageBuffer &)*encodedImageBuffer); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result); + return jresult; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-adaptor/event-thread-callback-wrap.cpp b/dali-csharp-binder/dali-adaptor/event-thread-callback-wrap.cpp new file mode 100755 index 00000000..59739cfb --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/event-thread-callback-wrap.cpp @@ -0,0 +1,100 @@ +/* + * Copyright (c) 2017 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void (SWIGSTDCALL* SWIG_CallbackMakeCallback)(void); + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EventThreadCallback(SWIG_CallbackMakeCallback callbackOnMakeCallback) { + void * jresult ; + void (*arg1)(void) = (void (*)(void)) 0 ; + Dali::EventThreadCallback *result = 0 ; + Dali::CallbackBase * callbackBase = 0 ; + + arg1 = (void (*)(void))callbackOnMakeCallback; + callbackBase = (Dali::CallbackBase *)Dali::MakeCallback(arg1); + + { + try { + result = (Dali::EventThreadCallback *)new Dali::EventThreadCallback(callbackBase); + } catch (std::out_of_range& e) { + { + delete result; + delete callbackBase; + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; + }; + } catch (std::exception& e) { + { + delete result; + delete callbackBase; + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; + }; + } catch (Dali::DaliException e) { + { + delete result; + delete callbackBase; + SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; + }; + } catch (...) { + { + delete result; + delete callbackBase; + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; + }; + } + } + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EventThreadCallback(void * jarg1) { + Dali::EventThreadCallback *arg1 = (Dali::EventThreadCallback *) 0 ; + + arg1 = (Dali::EventThreadCallback *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_EventThreadCallback_Trigger(void * jarg1) { + Dali::EventThreadCallback *arg1 = (Dali::EventThreadCallback *) 0 ; + + arg1 = (Dali::EventThreadCallback *)jarg1; + { + try { + (arg1)->Trigger(); + } CALL_CATCH_EXCEPTION(); + } + +} + +#ifdef __cplusplus +} +#endif //CSHARP_EVENT_THREAD_CALLBACK + diff --git a/dali-csharp-binder/dali-adaptor/font-client-wrap.cpp b/dali-csharp-binder/dali-adaptor/font-client-wrap.cpp new file mode 100755 index 00000000..51a7153e --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/font-client-wrap.cpp @@ -0,0 +1,1859 @@ +/* + * Copyright (c) 2017 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include +#include +#include +#include +#include + +// INTERNAL INCLUDES +#include + +/* Callback for returning strings to C# without leaking memory */ +typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + + +typedef std::string FontPath; +typedef std::string FontFamily; +typedef std::string FontStyle; +typedef std::vector FontPathList; +typedef std::vector FontFamilyList; +typedef std::vector FontList; + +typedef uint32_t FontId; +typedef uint32_t PointSize26Dot6; +typedef uint32_t FaceIndex; +typedef uint32_t GlyphIndex; +typedef uint32_t Character; +typedef uint32_t CharacterIndex; +typedef uint32_t Length; +typedef uint32_t BidiInfoIndex; +typedef char LineBreakInfo; +typedef char WordBreakInfo; +typedef bool CharacterDirection; + + +#ifdef __cplusplus +extern "C" { +#endif + + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FontClient_SWIGUpcast(Dali::TextAbstraction::FontClient *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_PreCache(char ** fallbackFamilyArray, int fallbackFamilySize, char ** extraFamilyArray, int extraFamilySize, char * localeFamilyString, bool useThread, bool syncCreation) { + FontFamilyList fallbackFamilyList; + FontFamilyList extraFamilyList; + FontFamily localeFamily = localeFamilyString ? localeFamilyString : ""; + + if(fallbackFamilyArray) + { + fallbackFamilyList.assign(fallbackFamilyArray, fallbackFamilyArray + fallbackFamilySize); + } + + if(extraFamilyArray) + { + extraFamilyList.assign(extraFamilyArray, extraFamilyArray + extraFamilySize); + } + + Dali::TextAbstraction::FontClientPreCache(fallbackFamilyList, extraFamilyList, localeFamily, useThread, syncCreation); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_FontPreLoad(char ** fontPathArray, int fontPathSize, char ** memoryFontPathArray, int memoryFontPathSize, bool useThread, bool syncCreation) { + FontPathList fontPathList; + FontPathList memoryFontPathList; + + if(fontPathArray) + { + fontPathList.assign(fontPathArray, fontPathArray + fontPathSize); + } + + if(memoryFontPathArray) + { + memoryFontPathList.assign(memoryFontPathArray, memoryFontPathArray + memoryFontPathSize); + } + + Dali::TextAbstraction::FontClientFontPreLoad(fontPathList, memoryFontPathList, useThread, syncCreation); +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontWidthName_get() { + void * jresult ; + char **result = 0 ; + + result = (char **)(char **)Dali::TextAbstraction::FontWidth::Name; + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontWeightName_get() { + void * jresult ; + char **result = 0 ; + + result = (char **)(char **)Dali::TextAbstraction::FontWeight::Name; + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontSlantName_get() { + void * jresult ; + char **result = 0 ; + + result = (char **)(char **)Dali::TextAbstraction::FontSlant::Name; + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FontDescription() { + void * jresult ; + Dali::TextAbstraction::FontDescription *result = 0 ; + + { + try { + result = (Dali::TextAbstraction::FontDescription *)new Dali::TextAbstraction::FontDescription(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FontDescription(void * jarg1) { + Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; + + arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontDescription_path_set(void * jarg1, char * jarg2) { + Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; + Dali::TextAbstraction::FontPath *arg2 = 0 ; + + arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + Dali::TextAbstraction::FontPath arg2_str(jarg2); + arg2 = &arg2_str; + if (arg1) (arg1)->path = *arg2; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_FontDescription_path_get(void * jarg1) { + char * jresult ; + Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; + Dali::TextAbstraction::FontPath *result = 0 ; + + arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; + result = (Dali::TextAbstraction::FontPath *) & ((arg1)->path); + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontDescription_family_set(void * jarg1, char * jarg2) { + Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; + Dali::TextAbstraction::FontFamily *arg2 = 0 ; + + arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + Dali::TextAbstraction::FontFamily arg2_str(jarg2); + arg2 = &arg2_str; + if (arg1) (arg1)->family = *arg2; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_FontDescription_family_get(void * jarg1) { + char * jresult ; + Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; + Dali::TextAbstraction::FontFamily *result = 0 ; + + arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; + result = (Dali::TextAbstraction::FontFamily *) & ((arg1)->family); + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontDescription_width_set(void * jarg1, int jarg2) { + Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; + Dali::TextAbstraction::FontWidth::Type arg2 ; + + arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; + arg2 = (Dali::TextAbstraction::FontWidth::Type)jarg2; + if (arg1) (arg1)->width = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontDescription_width_get(void * jarg1) { + int jresult ; + Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; + Dali::TextAbstraction::FontWidth::Type result; + + arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; + result = (Dali::TextAbstraction::FontWidth::Type) ((arg1)->width); + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontDescription_weight_set(void * jarg1, int jarg2) { + Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; + Dali::TextAbstraction::FontWeight::Type arg2 ; + + arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; + arg2 = (Dali::TextAbstraction::FontWeight::Type)jarg2; + if (arg1) (arg1)->weight = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontDescription_weight_get(void * jarg1) { + int jresult ; + Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; + Dali::TextAbstraction::FontWeight::Type result; + + arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; + result = (Dali::TextAbstraction::FontWeight::Type) ((arg1)->weight); + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontDescription_slant_set(void * jarg1, int jarg2) { + Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; + Dali::TextAbstraction::FontSlant::Type arg2 ; + + arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; + arg2 = (Dali::TextAbstraction::FontSlant::Type)jarg2; + if (arg1) (arg1)->slant = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontDescription_slant_get(void * jarg1) { + int jresult ; + Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; + Dali::TextAbstraction::FontSlant::Type result; + + arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; + result = (Dali::TextAbstraction::FontSlant::Type) ((arg1)->slant); + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FontMetrics__SWIG_0() { + void * jresult ; + Dali::TextAbstraction::FontMetrics *result = 0 ; + + { + try { + result = (Dali::TextAbstraction::FontMetrics *)new Dali::TextAbstraction::FontMetrics(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FontMetrics__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5) { + void * jresult ; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + Dali::TextAbstraction::FontMetrics *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + arg5 = (float)jarg5; + { + try { + result = (Dali::TextAbstraction::FontMetrics *)new Dali::TextAbstraction::FontMetrics(arg1,arg2,arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontMetrics_ascender_set(void * jarg1, float jarg2) { + Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; + float arg2 ; + + arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->ascender = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FontMetrics_ascender_get(void * jarg1) { + float jresult ; + Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; + float result; + + arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; + result = (float) ((arg1)->ascender); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontMetrics_descender_set(void * jarg1, float jarg2) { + Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; + float arg2 ; + + arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->descender = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FontMetrics_descender_get(void * jarg1) { + float jresult ; + Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; + float result; + + arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; + result = (float) ((arg1)->descender); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontMetrics_height_set(void * jarg1, float jarg2) { + Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; + float arg2 ; + + arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->height = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FontMetrics_height_get(void * jarg1) { + float jresult ; + Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; + float result; + + arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; + result = (float) ((arg1)->height); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontMetrics_underlinePosition_set(void * jarg1, float jarg2) { + Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; + float arg2 ; + + arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->underlinePosition = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FontMetrics_underlinePosition_get(void * jarg1) { + float jresult ; + Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; + float result; + + arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; + result = (float) ((arg1)->underlinePosition); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontMetrics_underlineThickness_set(void * jarg1, float jarg2) { + Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; + float arg2 ; + + arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->underlineThickness = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FontMetrics_underlineThickness_get(void * jarg1) { + float jresult ; + Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; + float result; + + arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; + result = (float) ((arg1)->underlineThickness); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FontMetrics(void * jarg1) { + Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; + + arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LINE_MUST_BREAK_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::TextAbstraction::LINE_MUST_BREAK; + } CALL_CATCH_EXCEPTION(0); + } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LINE_ALLOW_BREAK_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::TextAbstraction::LINE_ALLOW_BREAK; + } CALL_CATCH_EXCEPTION(0); + } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LINE_NO_BREAK_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::TextAbstraction::LINE_NO_BREAK; + } CALL_CATCH_EXCEPTION(0); + } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WORD_BREAK_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::TextAbstraction::WORD_BREAK; + } CALL_CATCH_EXCEPTION(0); + } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WORD_NO_BREAK_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::TextAbstraction::WORD_NO_BREAK; + } CALL_CATCH_EXCEPTION(0); + } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBlob_r_set(void * jarg1, unsigned char jarg2) { + Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ; + unsigned char arg2 ; + + arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1; + arg2 = (unsigned char)jarg2; + if (arg1) (arg1)->r = arg2; +} + + +SWIGEXPORT unsigned char SWIGSTDCALL CSharp_Dali_VectorBlob_r_get(void * jarg1) { + unsigned char jresult ; + Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ; + unsigned char result; + + arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1; + result = (unsigned char) ((arg1)->r); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBlob_g_set(void * jarg1, unsigned char jarg2) { + Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ; + unsigned char arg2 ; + + arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1; + arg2 = (unsigned char)jarg2; + if (arg1) (arg1)->g = arg2; +} + + +SWIGEXPORT unsigned char SWIGSTDCALL CSharp_Dali_VectorBlob_g_get(void * jarg1) { + unsigned char jresult ; + Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ; + unsigned char result; + + arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1; + result = (unsigned char) ((arg1)->g); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBlob_b_set(void * jarg1, unsigned char jarg2) { + Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ; + unsigned char arg2 ; + + arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1; + arg2 = (unsigned char)jarg2; + if (arg1) (arg1)->b = arg2; +} + + +SWIGEXPORT unsigned char SWIGSTDCALL CSharp_Dali_VectorBlob_b_get(void * jarg1) { + unsigned char jresult ; + Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ; + unsigned char result; + + arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1; + result = (unsigned char) ((arg1)->b); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBlob_a_set(void * jarg1, unsigned char jarg2) { + Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ; + unsigned char arg2 ; + + arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1; + arg2 = (unsigned char)jarg2; + if (arg1) (arg1)->a = arg2; +} + + +SWIGEXPORT unsigned char SWIGSTDCALL CSharp_Dali_VectorBlob_a_get(void * jarg1) { + unsigned char jresult ; + Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ; + unsigned char result; + + arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1; + result = (unsigned char) ((arg1)->a); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorBlob() { + void * jresult ; + Dali::TextAbstraction::VectorBlob *result = 0 ; + + { + try { + result = (Dali::TextAbstraction::VectorBlob *)new Dali::TextAbstraction::VectorBlob(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorBlob(void * jarg1) { + Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ; + + arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GlyphInfo__SWIG_0() { + void * jresult ; + Dali::TextAbstraction::GlyphInfo *result = 0 ; + + { + try { + result = (Dali::TextAbstraction::GlyphInfo *)new Dali::TextAbstraction::GlyphInfo(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GlyphInfo__SWIG_1(unsigned int jarg1, unsigned int jarg2) { + void * jresult ; + Dali::TextAbstraction::FontId arg1 ; + Dali::TextAbstraction::GlyphIndex arg2 ; + Dali::TextAbstraction::GlyphInfo *result = 0 ; + + arg1 = (Dali::TextAbstraction::FontId)jarg1; + arg2 = (Dali::TextAbstraction::GlyphIndex)jarg2; + { + try { + result = (Dali::TextAbstraction::GlyphInfo *)new Dali::TextAbstraction::GlyphInfo(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_fontId_set(void * jarg1, unsigned int jarg2) { + Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; + Dali::TextAbstraction::FontId arg2 ; + + arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; + arg2 = (Dali::TextAbstraction::FontId)jarg2; + if (arg1) (arg1)->fontId = arg2; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlyphInfo_fontId_get(void * jarg1) { + unsigned int jresult ; + Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; + Dali::TextAbstraction::FontId result; + + arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; + result = ((arg1)->fontId); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_index_set(void * jarg1, unsigned int jarg2) { + Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; + Dali::TextAbstraction::GlyphIndex arg2 ; + + arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; + arg2 = (Dali::TextAbstraction::GlyphIndex)jarg2; + if (arg1) (arg1)->index = arg2; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlyphInfo_index_get(void * jarg1) { + unsigned int jresult ; + Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; + Dali::TextAbstraction::GlyphIndex result; + + arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; + result = ((arg1)->index); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_width_set(void * jarg1, float jarg2) { + Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; + float arg2 ; + + arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->width = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GlyphInfo_width_get(void * jarg1) { + float jresult ; + Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; + float result; + + arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; + result = (float) ((arg1)->width); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_height_set(void * jarg1, float jarg2) { + Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; + float arg2 ; + + arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->height = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GlyphInfo_height_get(void * jarg1) { + float jresult ; + Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; + float result; + + arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; + result = (float) ((arg1)->height); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_xBearing_set(void * jarg1, float jarg2) { + Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; + float arg2 ; + + arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->xBearing = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GlyphInfo_xBearing_get(void * jarg1) { + float jresult ; + Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; + float result; + + arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; + result = (float) ((arg1)->xBearing); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_yBearing_set(void * jarg1, float jarg2) { + Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; + float arg2 ; + + arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->yBearing = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GlyphInfo_yBearing_get(void * jarg1) { + float jresult ; + Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; + float result; + + arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; + result = (float) ((arg1)->yBearing); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_advance_set(void * jarg1, float jarg2) { + Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; + float arg2 ; + + arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->advance = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GlyphInfo_advance_get(void * jarg1) { + float jresult ; + Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; + float result; + + arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; + result = (float) ((arg1)->advance); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_scaleFactor_set(void * jarg1, float jarg2) { + Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; + float arg2 ; + + arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->scaleFactor = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GlyphInfo_scaleFactor_get(void * jarg1) { + float jresult ; + Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; + float result; + + arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; + result = (float) ((arg1)->scaleFactor); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GlyphInfo(void * jarg1) { + Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; + + arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_DEFAULT_POINT_SIZE_get() { + unsigned int jresult ; + Dali::TextAbstraction::PointSize26Dot6 result; + + result = (Dali::TextAbstraction::PointSize26Dot6)Dali::TextAbstraction::FontClient::DEFAULT_POINT_SIZE; + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FontClient_GlyphBufferData() { + void * jresult ; + Dali::TextAbstraction::GlyphBufferData *result = 0 ; + + { + try { + result = (Dali::TextAbstraction::GlyphBufferData *)new Dali::TextAbstraction::GlyphBufferData(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FontClient_GlyphBufferData(void * jarg1) { + Dali::TextAbstraction::GlyphBufferData *arg1 = (Dali::TextAbstraction::GlyphBufferData *) 0 ; + + arg1 = (Dali::TextAbstraction::GlyphBufferData *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +/* +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_buffer_set(void * jarg1, unsigned char* jarg2) { + Dali::TextAbstraction::GlyphBufferData *arg1 = (Dali::TextAbstraction::GlyphBufferData *) 0 ; + unsigned char *arg2 = (unsigned char *) 0 ; + + arg1 = (Dali::TextAbstraction::GlyphBufferData *)jarg1; + arg2 = jarg2; + if (arg1) (arg1)->buffer = arg2; + + +} + + +SWIGEXPORT unsigned char* SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_buffer_get(void * jarg1) { + unsigned char* jresult ; + Dali::TextAbstraction::GlyphBufferData *arg1 = (Dali::TextAbstraction::GlyphBufferData *) 0 ; + unsigned char *result = 0 ; + + arg1 = (Dali::TextAbstraction::GlyphBufferData *)jarg1; + result = (unsigned char *) ((arg1)->buffer); + jresult = (void *)result; + return jresult; +} +*/ + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_width_set(void * jarg1, unsigned int jarg2) { + Dali::TextAbstraction::GlyphBufferData *arg1 = (Dali::TextAbstraction::GlyphBufferData *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::TextAbstraction::GlyphBufferData *)jarg1; + arg2 = (unsigned int)jarg2; + if (arg1) (arg1)->width = arg2; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_width_get(void * jarg1) { + unsigned int jresult ; + Dali::TextAbstraction::GlyphBufferData *arg1 = (Dali::TextAbstraction::GlyphBufferData *) 0 ; + unsigned int result; + + arg1 = (Dali::TextAbstraction::GlyphBufferData *)jarg1; + result = (unsigned int) ((arg1)->width); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_height_set(void * jarg1, unsigned int jarg2) { + Dali::TextAbstraction::GlyphBufferData *arg1 = (Dali::TextAbstraction::GlyphBufferData *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::TextAbstraction::GlyphBufferData *)jarg1; + arg2 = (unsigned int)jarg2; + if (arg1) (arg1)->height = arg2; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_height_get(void * jarg1) { + unsigned int jresult ; + Dali::TextAbstraction::GlyphBufferData *arg1 = (Dali::TextAbstraction::GlyphBufferData *) 0 ; + unsigned int result; + + arg1 = (Dali::TextAbstraction::GlyphBufferData *)jarg1; + result = (unsigned int) ((arg1)->height); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_format_set(void * jarg1, int jarg2) { + Dali::TextAbstraction::GlyphBufferData *arg1 = (Dali::TextAbstraction::GlyphBufferData *) 0 ; + Dali::Pixel::Format arg2 ; + + arg1 = (Dali::TextAbstraction::GlyphBufferData *)jarg1; + arg2 = (Dali::Pixel::Format)jarg2; + if (arg1) (arg1)->format = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_format_get(void * jarg1) { + int jresult ; + Dali::TextAbstraction::GlyphBufferData *arg1 = (Dali::TextAbstraction::GlyphBufferData *) 0 ; + Dali::Pixel::Format result; + + arg1 = (Dali::TextAbstraction::GlyphBufferData *)jarg1; + result = (Dali::Pixel::Format) ((arg1)->format); + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontClient_Get() { + void * jresult ; + Dali::TextAbstraction::FontClient result; + + { + try { + result = Dali::TextAbstraction::FontClient::Get(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::TextAbstraction::FontClient((const Dali::TextAbstraction::FontClient &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FontClient__SWIG_0() { + void * jresult ; + Dali::TextAbstraction::FontClient *result = 0 ; + + { + try { + result = (Dali::TextAbstraction::FontClient *)new Dali::TextAbstraction::FontClient(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FontClient(void * jarg1) { + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FontClient__SWIG_1(void * jarg1) { + void * jresult ; + Dali::TextAbstraction::FontClient *arg1 = 0 ; + Dali::TextAbstraction::FontClient *result = 0 ; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontClient const & type is null", 0); + return 0; + } + { + try { + result = (Dali::TextAbstraction::FontClient *)new Dali::TextAbstraction::FontClient((Dali::TextAbstraction::FontClient const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontClient_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontClient *arg2 = 0 ; + Dali::TextAbstraction::FontClient *result = 0 ; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::FontClient *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontClient const & type is null", 0); + return 0; + } + { + try { + result = (Dali::TextAbstraction::FontClient *) &(arg1)->operator =((Dali::TextAbstraction::FontClient const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_SetDpi(void * jarg1, unsigned int jarg2, unsigned int jarg3) { + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + unsigned int arg2 ; + unsigned int arg3 ; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (unsigned int)jarg3; + { + try { + (arg1)->SetDpi(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetDpi(void * jarg1, void * jarg2, void * jarg3) { + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + unsigned int *arg2 = 0 ; + unsigned int *arg3 = 0 ; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (unsigned int *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "unsigned int & type is null", 0); + return ; + } + arg3 = (unsigned int *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "unsigned int & type is null", 0); + return ; + } + { + try { + (arg1)->GetDpi(*arg2,*arg3); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontClient_GetDefaultFontSize(void * jarg1) { + int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + int result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + { + try { + result = (int)(arg1)->GetDefaultFontSize(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_ResetSystemDefaults(void * jarg1) { + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + { + try { + (arg1)->ResetSystemDefaults(); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetDefaultFonts(void * jarg1, void * jarg2) { + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontList *arg2 = 0 ; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::FontList *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontList & type is null", 0); + return ; + } + { + try { + (arg1)->GetDefaultFonts(*arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetDefaultPlatformFontDescription(void * jarg1, void * jarg2) { + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontDescription *arg2 = 0 ; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::FontDescription *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription & type is null", 0); + return ; + } + { + try { + (arg1)->GetDefaultPlatformFontDescription(*arg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontClient_GetSystemFonts(void* fontClient) { + void* jresult; + Dali::Property::Array *array = 0; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0; + + arg1 = (Dali::TextAbstraction::FontClient *)fontClient; + { + try { + FontList fontList; + (arg1)->GetSystemFonts(fontList); + + Dali::Property::Array systemFonts; + for(size_t i = 0; i < fontList.size(); i++) + { + Dali::Property::Map font; + font.Add("family", fontList[i].family); + font.Add("path", fontList[i].path); + font.Add("width", fontList[i].width); + font.Add("weight", fontList[i].weight); + font.Add("slant", fontList[i].slant); + systemFonts.PushBack(font); + } + + array = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)systemFonts); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)array; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetDescription(void * jarg1, unsigned int jarg2, void * jarg3) { + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontId arg2 ; + Dali::TextAbstraction::FontDescription *arg3 = 0 ; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::FontId)jarg2; + arg3 = (Dali::TextAbstraction::FontDescription *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription & type is null", 0); + return ; + } + { + try { + (arg1)->GetDescription(arg2,*arg3); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetPointSize(void * jarg1, unsigned int jarg2) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontId arg2 ; + Dali::TextAbstraction::PointSize26Dot6 result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::FontId)jarg2; + { + try { + result = (arg1)->GetPointSize(arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_IsCharacterSupportedByFont(void * jarg1, unsigned int jarg2, unsigned int jarg3) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontId arg2 ; + Dali::TextAbstraction::Character arg3 ; + bool result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::FontId)jarg2; + arg3 = (Dali::TextAbstraction::Character)jarg3; + { + try { + result = (bool)(arg1)->IsCharacterSupportedByFont(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_FindDefaultFont__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::Character arg2 ; + Dali::TextAbstraction::PointSize26Dot6 arg3 ; + bool arg4 ; + Dali::TextAbstraction::FontId result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::Character)jarg2; + arg3 = (Dali::TextAbstraction::PointSize26Dot6)jarg3; + arg4 = jarg4 ? true : false; + { + try { + result = (arg1)->FindDefaultFont(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_FindDefaultFont__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::Character arg2 ; + Dali::TextAbstraction::PointSize26Dot6 arg3 ; + Dali::TextAbstraction::FontId result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::Character)jarg2; + arg3 = (Dali::TextAbstraction::PointSize26Dot6)jarg3; + { + try { + result = (arg1)->FindDefaultFont(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_FindDefaultFont__SWIG_2(void * jarg1, unsigned int jarg2) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::Character arg2 ; + Dali::TextAbstraction::FontId result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::Character)jarg2; + { + try { + result = (arg1)->FindDefaultFont(arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_FindFallbackFont__SWIG_0(void * jarg1, unsigned int jarg2, void * jarg3, unsigned int jarg4, unsigned int jarg5) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::Character arg2 ; + Dali::TextAbstraction::FontDescription *arg3 = 0 ; + Dali::TextAbstraction::PointSize26Dot6 arg4 ; + bool arg5 ; + Dali::TextAbstraction::FontId result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::Character)jarg2; + arg3 = (Dali::TextAbstraction::FontDescription *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0); + return 0; + } + arg4 = (Dali::TextAbstraction::PointSize26Dot6)jarg4; + arg5 = jarg5 ? true : false; + { + try { + result = (arg1)->FindFallbackFont(arg2,(Dali::TextAbstraction::FontDescription const &)*arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_FindFallbackFont__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3, unsigned int jarg4) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::Character arg2 ; + Dali::TextAbstraction::FontDescription *arg3 = 0 ; + Dali::TextAbstraction::PointSize26Dot6 arg4 ; + Dali::TextAbstraction::FontId result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::Character)jarg2; + arg3 = (Dali::TextAbstraction::FontDescription *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0); + return 0; + } + arg4 = (Dali::TextAbstraction::PointSize26Dot6)jarg4; + { + try { + result = (arg1)->FindFallbackFont(arg2,(Dali::TextAbstraction::FontDescription const &)*arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_FindFallbackFont__SWIG_2(void * jarg1, unsigned int jarg2, void * jarg3) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::Character arg2 ; + Dali::TextAbstraction::FontDescription *arg3 = 0 ; + Dali::TextAbstraction::FontId result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::Character)jarg2; + arg3 = (Dali::TextAbstraction::FontDescription *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0); + return 0; + } + { + try { + result = (arg1)->FindFallbackFont(arg2,(Dali::TextAbstraction::FontDescription const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetFontId__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontPath *arg2 = 0 ; + Dali::TextAbstraction::PointSize26Dot6 arg3 ; + Dali::TextAbstraction::FaceIndex arg4 ; + Dali::TextAbstraction::FontId result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + Dali::TextAbstraction::FontPath arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::TextAbstraction::PointSize26Dot6)jarg3; + arg4 = (Dali::TextAbstraction::FaceIndex)jarg4; + { + try { + result = (arg1)->GetFontId((Dali::TextAbstraction::FontPath const &)*arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetFontId__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontPath *arg2 = 0 ; + Dali::TextAbstraction::PointSize26Dot6 arg3 ; + Dali::TextAbstraction::FontId result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + Dali::TextAbstraction::FontPath arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::TextAbstraction::PointSize26Dot6)jarg3; + { + try { + result = (arg1)->GetFontId((Dali::TextAbstraction::FontPath const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetFontId__SWIG_2(void * jarg1, char * jarg2) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontPath *arg2 = 0 ; + Dali::TextAbstraction::FontId result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + Dali::TextAbstraction::FontPath arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + result = (arg1)->GetFontId((Dali::TextAbstraction::FontPath const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetFontId__SWIG_3(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontDescription *arg2 = 0 ; + Dali::TextAbstraction::PointSize26Dot6 arg3 ; + Dali::TextAbstraction::FaceIndex arg4 ; + Dali::TextAbstraction::FontId result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::FontDescription *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0); + return 0; + } + arg3 = (Dali::TextAbstraction::PointSize26Dot6)jarg3; + arg4 = (Dali::TextAbstraction::FaceIndex)jarg4; + { + try { + result = (arg1)->GetFontId((Dali::TextAbstraction::FontDescription const &)*arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetFontId__SWIG_4(void * jarg1, void * jarg2, unsigned int jarg3) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontDescription *arg2 = 0 ; + Dali::TextAbstraction::PointSize26Dot6 arg3 ; + Dali::TextAbstraction::FontId result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::FontDescription *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0); + return 0; + } + arg3 = (Dali::TextAbstraction::PointSize26Dot6)jarg3; + { + try { + result = (arg1)->GetFontId((Dali::TextAbstraction::FontDescription const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetFontId__SWIG_5(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontDescription *arg2 = 0 ; + Dali::TextAbstraction::FontId result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::FontDescription *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0); + return 0; + } + { + try { + result = (arg1)->GetFontId((Dali::TextAbstraction::FontDescription const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_IsScalable__SWIG_0(void * jarg1, char * jarg2) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontPath *arg2 = 0 ; + bool result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + Dali::TextAbstraction::FontPath arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + result = (bool)(arg1)->IsScalable((Dali::TextAbstraction::FontPath const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_IsScalable__SWIG_1(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontDescription *arg2 = 0 ; + bool result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::FontDescription *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0); + return 0; + } + { + try { + result = (bool)(arg1)->IsScalable((Dali::TextAbstraction::FontDescription const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetFixedSizes__SWIG_0(void * jarg1, char * jarg2, void * jarg3) { + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontPath *arg2 = 0 ; + Dali::Vector< Dali::TextAbstraction::PointSize26Dot6,Dali::TypeTraits< Dali::TextAbstraction::PointSize26Dot6 >::IS_TRIVIAL_TYPE==true > *arg3 = 0 ; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + Dali::TextAbstraction::FontPath arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Vector< Dali::TextAbstraction::PointSize26Dot6,Dali::TypeTraits< Dali::TextAbstraction::PointSize26Dot6 >::IS_TRIVIAL_TYPE==true > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::TextAbstraction::PointSize26Dot6,Dali::TypeTraits< Dali::TextAbstraction::PointSize26Dot6 >::IS_TRIVIAL_TYPE==true > & type is null", 0); + return ; + } + { + try { + (arg1)->GetFixedSizes((Dali::TextAbstraction::FontPath const &)*arg2,*arg3); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetFixedSizes__SWIG_1(void * jarg1, void * jarg2, void * jarg3) { + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontDescription *arg2 = 0 ; + Dali::Vector< Dali::TextAbstraction::PointSize26Dot6,Dali::TypeTraits< Dali::TextAbstraction::PointSize26Dot6 >::IS_TRIVIAL_TYPE==true > *arg3 = 0 ; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::FontDescription *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0); + return ; + } + arg3 = (Dali::Vector< Dali::TextAbstraction::PointSize26Dot6,Dali::TypeTraits< Dali::TextAbstraction::PointSize26Dot6 >::IS_TRIVIAL_TYPE==true > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::TextAbstraction::PointSize26Dot6,Dali::TypeTraits< Dali::TextAbstraction::PointSize26Dot6 >::IS_TRIVIAL_TYPE==true > & type is null", 0); + return ; + } + { + try { + (arg1)->GetFixedSizes((Dali::TextAbstraction::FontDescription const &)*arg2,*arg3); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetFontMetrics(void * jarg1, unsigned int jarg2, void * jarg3) { + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontId arg2 ; + Dali::TextAbstraction::FontMetrics *arg3 = 0 ; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::FontId)jarg2; + arg3 = (Dali::TextAbstraction::FontMetrics *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontMetrics & type is null", 0); + return ; + } + { + try { + (arg1)->GetFontMetrics(arg2,*arg3); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetGlyphIndex(void * jarg1, unsigned int jarg2, unsigned int jarg3) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontId arg2 ; + Dali::TextAbstraction::Character arg3 ; + Dali::TextAbstraction::GlyphIndex result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::FontId)jarg2; + arg3 = (Dali::TextAbstraction::Character)jarg3; + { + try { + result = (arg1)->GetGlyphIndex(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetGlyphMetrics__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::GlyphInfo *arg2 = (Dali::TextAbstraction::GlyphInfo *) 0 ; + uint32_t arg3 ; + Dali::TextAbstraction::GlyphType arg4 ; + bool arg5 ; + bool result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::GlyphInfo *)jarg2; + arg3 = (uint32_t)jarg3; + arg4 = (Dali::TextAbstraction::GlyphType)jarg4; + arg5 = jarg5 ? true : false; + { + try { + result = (bool)(arg1)->GetGlyphMetrics(arg2,arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetGlyphMetrics__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::GlyphInfo *arg2 = (Dali::TextAbstraction::GlyphInfo *) 0 ; + uint32_t arg3 ; + Dali::TextAbstraction::GlyphType arg4 ; + bool result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::GlyphInfo *)jarg2; + arg3 = (uint32_t)jarg3; + arg4 = (Dali::TextAbstraction::GlyphType)jarg4; + { + try { + result = (bool)(arg1)->GetGlyphMetrics(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_CreateBitmap__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3, bool jarg4, bool jarg5, void * jarg6, int jarg7) { + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontId arg2 ; + Dali::TextAbstraction::GlyphIndex arg3 ; + bool arg4; + bool arg5; + Dali::TextAbstraction::GlyphBufferData *arg6 = 0 ; + int arg7 ; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::FontId)jarg2; + arg3 = (Dali::TextAbstraction::GlyphIndex)jarg3; + arg4 = jarg4; + arg5 = jarg5; + arg6 = (Dali::TextAbstraction::GlyphBufferData *)jarg6; + if (!arg6) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::GlyphBufferData & type is null", 0); + return ; + } + arg7 = (int)jarg7; + { + try { + (arg1)->CreateBitmap(arg2,arg3,arg4,arg5,*arg6,arg7); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontClient_CreateBitmap__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) { + void * jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontId arg2 ; + Dali::TextAbstraction::GlyphIndex arg3 ; + int arg4 ; + Dali::PixelData result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::FontId)jarg2; + arg3 = (Dali::TextAbstraction::GlyphIndex)jarg3; + arg4 = (int)jarg4; + { + try { + result = (arg1)->CreateBitmap(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::PixelData((const Dali::PixelData &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_CreateVectorBlob(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) { + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontId arg2 ; + Dali::TextAbstraction::GlyphIndex arg3 ; + Dali::TextAbstraction::VectorBlob **arg4 = 0 ; + unsigned int *arg5 = 0 ; + unsigned int *arg6 = 0 ; + unsigned int *arg7 = 0 ; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::FontId)jarg2; + arg3 = (Dali::TextAbstraction::GlyphIndex)jarg3; + arg4 = (Dali::TextAbstraction::VectorBlob **)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::VectorBlob *& type is null", 0); + return ; + } + arg5 = (unsigned int *)jarg5; + if (!arg5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "unsigned int & type is null", 0); + return ; + } + arg6 = (unsigned int *)jarg6; + if (!arg6) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "unsigned int & type is null", 0); + return ; + } + arg7 = (unsigned int *)jarg7; + if (!arg7) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "unsigned int & type is null", 0); + return ; + } + { + try { + (arg1)->CreateVectorBlob(arg2,arg3,*arg4,*arg5,*arg6,*arg7); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontClient_GetEllipsisGlyph(void * jarg1, unsigned int jarg2) { + void * jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::PointSize26Dot6 arg2 ; + Dali::TextAbstraction::GlyphInfo *result = 0 ; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::PointSize26Dot6)jarg2; + { + try { + result = (Dali::TextAbstraction::GlyphInfo *) &(arg1)->GetEllipsisGlyph(arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_IsColorGlyph(void * jarg1, unsigned int jarg2, unsigned int jarg3) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontId arg2 ; + Dali::TextAbstraction::GlyphIndex arg3 ; + bool result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + arg2 = (Dali::TextAbstraction::FontId)jarg2; + arg3 = (Dali::TextAbstraction::GlyphIndex)jarg3; + { + try { + result = (bool)(arg1)->IsColorGlyph(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_AddCustomFontDirectory(void * jarg1, char * jarg2) { + unsigned int jresult ; + Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; + Dali::TextAbstraction::FontPath *arg2 = 0 ; + bool result; + + arg1 = (Dali::TextAbstraction::FontClient *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + Dali::TextAbstraction::FontPath arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + result = (bool)(arg1)->AddCustomFontDirectory((Dali::TextAbstraction::FontPath const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/dali-adaptor/gl-window-wrap.cpp b/dali-csharp-binder/dali-adaptor/gl-window-wrap.cpp new file mode 100644 index 00000000..f483c372 --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/gl-window-wrap.cpp @@ -0,0 +1,1295 @@ +/* + * Copyright (c) 2020 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include + +/* Callback for returning strings to C# without leaking memory */ +typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +/* TODO Adding signal definition */ +SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal const *self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal const *self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal *self, void (*func)(Dali::GlWindow, bool)) +{ + self->Connect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal *self, void (*func)(Dali::GlWindow, bool)) +{ + self->Disconnect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal *self, Dali::GlWindow arg, bool focusIn) +{ + self->Emit(arg, focusIn); +} + +/*ResizeSignal*/ +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Empty(Dali::Signal const *self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__GetConnectionCount(Dali::Signal const *self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Connect(Dali::Signal *self, void (*func)(Dali::GlWindow::WindowSize)) +{ + self->Connect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Disconnect(Dali::Signal *self, void (*func)(Dali::GlWindow::WindowSize)) +{ + self->Disconnect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Emit(Dali::Signal *self, Dali::GlWindow::WindowSize arg) +{ + self->Emit(arg); +} + +#ifdef __cplusplus +extern "C" +{ +#endif + + /*Window binding*/ + SWIGEXPORT Dali::BaseHandle *SWIGSTDCALL CSharp_Dali_GlWindow_SWIGUpcast(Dali::GlWindow *jarg1) + { + return (Dali::BaseHandle *)jarg1; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_New__SWIG_0() + { + void *jresult; + Dali::GlWindow result; + { + try + { + + result = Dali::GlWindow::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::GlWindow((const Dali::GlWindow &)result); + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_New__SWIG_1(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::GlWindow 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::GlWindow::New(arg1, (std::string const &)*arg2, (std::string const &)*arg3, arg4); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::GlWindow((const Dali::GlWindow &)result); + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlWindow__SWIG_0() + { + void *jresult; + Dali::GlWindow *result = 0; + + { + try + { + result = (Dali::GlWindow *)new Dali::GlWindow(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GlWindow(void *jarg1) + { + Dali::GlWindow *arg1 = (Dali::GlWindow *)0; + + arg1 = (Dali::GlWindow *)jarg1; + { + try + { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlWindow__SWIG_1(void *jarg1) + { + void *jresult; + Dali::GlWindow *arg1 = 0; + Dali::GlWindow *result = 0; + + arg1 = (Dali::GlWindow *)jarg1; + if (!arg1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GlWindow const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::GlWindow *)new Dali::GlWindow((Dali::GlWindow const &)*arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_Assign(void *jarg1, void *jarg2) + { + void *jresult; + Dali::GlWindow *arg1 = (Dali::GlWindow *)0; + Dali::GlWindow *arg2 = 0; + Dali::GlWindow *result = 0; + + arg1 = (Dali::GlWindow *)jarg1; + arg2 = (Dali::GlWindow *)jarg2; + if (!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GlWindow const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::GlWindow *)&(arg1)->operator=((Dali::GlWindow const &)*arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetGraphicsConfig(void *jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, int jarg5) + { + Dali::GlWindow *arg1 = (Dali::GlWindow *)0; + bool arg2; + bool arg3; + int arg4; + Dali::GlWindow::GlesVersion arg5; + + arg1 = (Dali::GlWindow *)jarg1; + arg2 = (bool)jarg2; + arg3 = (bool)jarg3; + arg4 = jarg4; + arg5 = static_cast(jarg5); + { + try + { + (arg1)->SetGraphicsConfig(arg2, arg3, arg4, arg5); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Raise(void *jarg1) + { + Dali::GlWindow *arg1 = (Dali::GlWindow *)0; + + arg1 = (Dali::GlWindow *)jarg1; + { + try + { + (arg1)->Raise(); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Lower(void *jarg1) + { + Dali::GlWindow *arg1 = (Dali::GlWindow *)0; + + arg1 = (Dali::GlWindow *)jarg1; + { + try + { + (arg1)->Lower(); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Activate(void *jarg1) + { + Dali::GlWindow *arg1 = (Dali::GlWindow *)0; + + arg1 = (Dali::GlWindow *)jarg1; + { + try + { + (arg1)->Activate(); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Show(void *jarg1) + { + Dali::GlWindow arg1; + Dali::GlWindow *argp1; + + argp1 = (Dali::GlWindow *)jarg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return; + } + arg1 = *argp1; + { + try + { + arg1.Show(); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Hide(void *jarg1) + { + Dali::GlWindow arg1; + Dali::GlWindow *argp1; + + argp1 = (Dali::GlWindow *)jarg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return; + } + arg1 = *argp1; + { + try + { + arg1.Hide(); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetPositionSize(void *jarg1, void *jarg2) + { + Dali::GlWindow arg1; + Dali::GlWindow *argp1 = (Dali::GlWindow *)jarg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return; + } + arg1 = *argp1; + Dali::Rect *positionSize = (Dali::Rect *)jarg2; + if (!positionSize) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); + return; + } + { + try + { + arg1.SetPositionSize(*positionSize); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_GetPositionSize(void *jarg1) + { + void *jresult; + Dali::GlWindow arg1; + Dali::GlWindow *argp1; + Dali::PositionSize result; + + argp1 = (Dali::GlWindow *)jarg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return 0; + } + arg1 = *argp1; + { + try + { + result = arg1.GetPositionSize(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PositionSize((const Dali::PositionSize &)result); + return jresult; + } + + SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_GetSupportedAuxiliaryHintCount(void *jarg1) + { + unsigned int jresult; + Dali::GlWindow arg1; + Dali::GlWindow *argp1; + unsigned int result; + + argp1 = (Dali::GlWindow *)jarg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return 0; + } + arg1 = *argp1; + { + try + { + result = (unsigned int)arg1.GetSupportedAuxiliaryHintCount(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; + } + + SWIGEXPORT char *SWIGSTDCALL CSharp_Dali_GlWindow_GetSupportedAuxiliaryHint(void *jarg1, unsigned int jarg2) + { + char *jresult; + Dali::GlWindow arg1; + unsigned int arg2; + Dali::GlWindow *argp1; + std::string result; + + argp1 = (Dali::GlWindow *)jarg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return 0; + } + arg1 = *argp1; + arg2 = (unsigned int)jarg2; + { + try + { + result = arg1.GetSupportedAuxiliaryHint(arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback((&result)->c_str()); + return jresult; + } + + SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_AddAuxiliaryHint(void *jarg1, char *jarg2, char *jarg3) + { + unsigned int jresult; + Dali::GlWindow arg1; + std::string *arg2 = 0; + std::string *arg3 = 0; + Dali::GlWindow *argp1; + unsigned int result; + + argp1 = (Dali::GlWindow *)jarg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 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; + { + try + { + result = (unsigned int)arg1.AddAuxiliaryHint((std::string const &)*arg2, (std::string const &)*arg3); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + return jresult; + } + + SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_RemoveAuxiliaryHint(void *jarg1, unsigned int jarg2) + { + unsigned int jresult; + Dali::GlWindow arg1; + unsigned int arg2; + Dali::GlWindow *argp1; + bool result; + + argp1 = (Dali::GlWindow *)jarg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return 0; + } + arg1 = *argp1; + arg2 = (unsigned int)jarg2; + { + try + { + result = (bool)arg1.RemoveAuxiliaryHint(arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; + } + + SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_SetAuxiliaryHintValue(void *jarg1, unsigned int jarg2, char *jarg3) + { + unsigned int jresult; + Dali::GlWindow arg1; + unsigned int arg2; + std::string *arg3 = 0; + Dali::GlWindow *argp1; + bool result; + + argp1 = (Dali::GlWindow *)jarg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return 0; + } + arg1 = *argp1; + arg2 = (unsigned int)jarg2; + if (!jarg3) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg3_str(jarg3); + arg3 = &arg3_str; + { + try + { + result = (bool)arg1.SetAuxiliaryHintValue(arg2, (std::string const &)*arg3); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + return jresult; + } + + SWIGEXPORT char *SWIGSTDCALL CSharp_Dali_GlWindow_GetAuxiliaryHintValue(void *jarg1, unsigned int jarg2) + { + char *jresult; + Dali::GlWindow arg1; + unsigned int arg2; + Dali::GlWindow *argp1; + std::string result; + + argp1 = (Dali::GlWindow *)jarg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return 0; + } + arg1 = *argp1; + arg2 = (unsigned int)jarg2; + { + try + { + result = arg1.GetAuxiliaryHintValue(arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback((&result)->c_str()); + return jresult; + } + + SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_GetAuxiliaryHintId(void *jarg1, char *jarg2) + { + unsigned int jresult; + Dali::GlWindow arg1; + std::string *arg2 = 0; + Dali::GlWindow *argp1; + unsigned int result; + + argp1 = (Dali::GlWindow *)jarg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return 0; + } + arg1 = *argp1; + if (!jarg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try + { + result = (unsigned int)arg1.GetAuxiliaryHintId((std::string const &)*arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetInputRegion(void *jarg1, void *jarg2) + { + Dali::GlWindow arg1; + Dali::Rect *arg2 = 0; + Dali::GlWindow *argp1; + + argp1 = (Dali::GlWindow *)jarg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return; + } + arg1 = *argp1; + arg2 = (Dali::Rect *)jarg2; + if (!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); + return; + } + { + try + { + arg1.SetInputRegion((Dali::Rect const &)*arg2); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetOpaqueState(void *jarg1, unsigned int jarg2) + { + Dali::GlWindow arg1; + bool arg2; + Dali::GlWindow *argp1; + + argp1 = (Dali::GlWindow *)jarg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return; + } + arg1 = *argp1; + arg2 = jarg2 ? true : false; + { + try + { + arg1.SetOpaqueState(arg2); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_IsOpaqueState(void *jarg1) + { + unsigned int jresult; + Dali::GlWindow arg1; + Dali::GlWindow *argp1; + bool result; + + argp1 = (Dali::GlWindow *)jarg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return 0; + } + arg1 = *argp1; + { + try + { + result = (bool)arg1.IsOpaqueState(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GlWindow_GetCurrentOrientation(void *jarg1) + { + int jresult; + Dali::WindowOrientation result; + Dali::GlWindow *arg1 = (Dali::GlWindow *)0; + arg1 = (Dali::GlWindow *)jarg1; + if (!arg1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return 0; + } + { + try + { + result = (arg1)->GetCurrentOrientation(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetAvailableOrientations(void *jarg1, void *jarg2, int jarg3) + { + Dali::GlWindow *arg1 = (Dali::GlWindow *)jarg1; + if (!arg1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return; + } + Dali::Property::Array *arg2 = (static_cast(jarg2)); + unsigned int count = static_cast(jarg3); + + Dali::Vector angles; + angles.Resize(count); + for (Dali::Property::Array::SizeType i = 0; i < count; ++i) + { + int angle = arg2->GetElementAt(i).Get(); + angles[i] = static_cast(angle); + } + { + try + { + arg1->SetAvailableOrientations(angles); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetPreferredOrientation(void *jarg1, int jarg2) + { + Dali::GlWindow *arg1 = (Dali::GlWindow *)0; + Dali::WindowOrientation arg2; + int angle = jarg2; + + arg1 = (Dali::GlWindow *)jarg1; + arg2 = (Dali::WindowOrientation)angle; + { + try + { + (arg1)->SetPreferredOrientation(arg2); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_RegisterGlCallbacks(void *jarg1, void *initCallback, int *RenderFrameCallback, void *terminateCallback) + { + Dali::GlWindow *argp1 = (Dali::GlWindow *)jarg1; + void (*initCB)() = (void (*)())initCallback; + int (*renderFrameCB)() = (int (*)())RenderFrameCallback; + void (*terminateCB)() = (void (*)())terminateCallback; + + if (!argp1 || !initCB || !renderFrameCB || !terminateCB) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null", 0); + return; + } + Dali::GlWindow arg1 = *argp1; + try + { + arg1.RegisterGlCallbacks(Dali::MakeCallback(initCB), Dali::MakeCallback(renderFrameCB), Dali::MakeCallback(terminateCB)); + } + CALL_CATCH_EXCEPTION(); + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_RenderOnce(void *jarg1) + { + Dali::GlWindow *argp1 = (Dali::GlWindow *)jarg1; + Dali::GlWindow arg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return; + } + arg1 = *argp1; + { + try + { + arg1.RenderOnce(); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GlWindow_GetRenderingMode(void *jarg1) + { + int jresult; + Dali::GlWindow *arg1 = (Dali::GlWindow *)0; + Dali::GlWindow::RenderingMode result; + + arg1 = (Dali::GlWindow *)jarg1; + if (!arg1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return 0; + } + + { + try + { + result = (Dali::GlWindow::RenderingMode)(arg1)->GetRenderingMode(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetRenderingMode(void *jarg1, int jarg2) + { + Dali::GlWindow *arg1 = (Dali::GlWindow *)0; + Dali::GlWindow::RenderingMode arg2; + + arg1 = (Dali::GlWindow *)jarg1; + if (!arg1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return; + } + arg2 = (Dali::GlWindow::RenderingMode)jarg2; + { + try + { + (arg1)->SetRenderingMode(arg2); + } + CALL_CATCH_EXCEPTION(); + } + } + + /* Signals binding*/ + + /* Focus change binding */ + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_FocusChangedSignal(void *jarg1) + { + void *jresult; + Dali::GlWindow arg1; + Dali::GlWindow *argp1; + Dali::GlWindow::FocusChangeSignalType *result = 0; + + argp1 = (Dali::GlWindow *)jarg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return 0; + } + arg1 = *argp1; + { + try + { + result = (Dali::GlWindow::FocusChangeSignalType *)&arg1.FocusChangeSignal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Empty(void *jarg1) + { + unsigned int jresult; + Dali::Signal *arg1 = (Dali::Signal *)0; + bool result; + + arg1 = (Dali::Signal *)jarg1; + { + try + { + result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal const *)arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; + } + + SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_GetConnectionCount(void *jarg1) + { + unsigned long jresult; + Dali::Signal *arg1 = (Dali::Signal *)0; + std::size_t result; + + arg1 = (Dali::Signal *)jarg1; + { + try + { + result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal const *)arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Connect(void *jarg1, void *jarg2) + { + Dali::Signal *arg1 = (Dali::Signal *)0; + void (*arg2)(Dali::GlWindow, bool) = (void (*)(Dali::GlWindow, bool))0; + + arg1 = (Dali::Signal *)jarg1; + arg2 = (void (*)(Dali::GlWindow, bool))jarg2; + { + try + { + Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Disconnect(void *jarg1, void *jarg2) + { + Dali::Signal *arg1 = (Dali::Signal *)0; + void (*arg2)(Dali::GlWindow, bool) = (void (*)(Dali::GlWindow, bool))0; + + arg1 = (Dali::Signal *)jarg1; + arg2 = (void (*)(Dali::GlWindow, bool))jarg2; + { + try + { + Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Emit(void *jarg1, void *jarg2, unsigned int jarg3) + { + Dali::Signal *arg1 = (Dali::Signal *)jarg1; + Dali::GlWindow *arg2 = (Dali::GlWindow *)jarg2; + bool arg3 = jarg3 ? true : false; + ; + + if (arg1 == nullptr || arg2 == nullptr) + { + DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr"); + return; + } + + { + try + { + Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1, *arg2, arg3); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlWindow_FocusSignalType() + { + void *jresult; + Dali::Signal *result = 0; + + { + try + { + result = (Dali::Signal *)new Dali::Signal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GlWindow_FocusSignalType(void *jarg1) + { + Dali::Signal *arg1 = (Dali::Signal *)0; + + arg1 = (Dali::Signal *)jarg1; + { + try + { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } + } + + /* Touch Event Binding */ + GENERATE_SIGNAL(Dali::GlWindow*, void(*)(Dali::TouchEvent const&), Dali_GlWindow, TouchedSignal) + // CSharp_Dali_GLWindow_TouchedSignal_Connect + // CSharp_Dali_GLWindow_TouchedSignal_Disconnect + + /*Key Event Binding */ + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_KeyEventSignal(void *jarg1) + { + void *jresult; + Dali::GlWindow *arg1 = (Dali::GlWindow *)0; + Dali::GlWindow::KeyEventSignalType *result = 0; + + arg1 = (Dali::GlWindow *)jarg1; + { + try + { + result = (Dali::GlWindow::KeyEventSignalType *)&(arg1->KeyEventSignal()); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + /* visibility change */ + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal(void *jarg1) + { + Dali::GlWindow *arg1 = (Dali::GlWindow *)jarg1; + Dali::GlWindow::VisibilityChangedSignalType *result = 0; + + { + try + { + result = (Dali::GlWindow::VisibilityChangedSignalType *)&(arg1->VisibilityChangedSignal()); + } + CALL_CATCH_EXCEPTION(0); + } + return (void *)result; + } + + SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_GetConnectionCount(void *jarg1) + { + unsigned int result; + Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1; + + if (arg1 == nullptr) + { + DALI_LOG_ERROR("[ERR] arg1 == nullptr"); + return 0; + } + + { + try + { + result = arg1->GetConnectionCount(); + } + CALL_CATCH_EXCEPTION(0); + } + return result; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_Connect(void *jarg1, void *jarg2) + { + Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1; + void (*arg2)(Dali::GlWindow, bool) = (void (*)(Dali::GlWindow, bool))jarg2; + + if (arg1 == nullptr) + { + DALI_LOG_ERROR("[ERR] arg1 == nullptr"); + return; + } + + { + try + { + arg1->Connect(arg2); + } + CALL_CATCH_EXCEPTION(); + } + return; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_Disconnect(void *jarg1, void *jarg2) + { + Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1; + void (*arg2)(Dali::GlWindow, bool) = (void (*)(Dali::GlWindow, bool))jarg2; + + if (arg1 == nullptr) + { + DALI_LOG_ERROR("[ERR] arg1 == nullptr"); + return; + } + + { + try + { + arg1->Disconnect(arg2); + } + CALL_CATCH_EXCEPTION(); + } + return; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_Emit(void *jarg1, void *jarg2, bool jarg3) + { + Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1; + Dali::GlWindow *arg2 = (Dali::GlWindow *)jarg2; + bool arg3 = jarg3; + + if (arg1 == nullptr || arg2 == nullptr) + { + DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr"); + return; + } + + { + try + { + arg1->Emit(*arg2, arg3); + } + CALL_CATCH_EXCEPTION(); + } + return; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_delete(void *jarg1) + { + Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1; + + { + try + { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } + return; + } + + /*ResizeSignal binding*/ + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal(void *jarg1) + { + void *jresult; + Dali::GlWindow arg1; + Dali::GlWindow *argp1; + Dali::GlWindow::ResizeSignalType *result = 0; + + argp1 = (Dali::GlWindow *)jarg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); + return 0; + } + arg1 = *argp1; + { + try + { + result = (Dali::GlWindow::ResizeSignalType *)&arg1.ResizeSignal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Empty(void *jarg1) + { + unsigned int jresult; + Dali::Signal *arg1 = (Dali::Signal *)0; + bool result; + + arg1 = (Dali::Signal *)jarg1; + { + try + { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Empty((Dali::Signal const *)arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; + } + + SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_GetConnectionCount(void *jarg1) + { + unsigned long jresult; + Dali::Signal *arg1 = (Dali::Signal *)0; + std::size_t result; + + arg1 = (Dali::Signal *)jarg1; + { + try + { + result = Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__GetConnectionCount((Dali::Signal const *)arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Connect(void *jarg1, void *jarg2) + { + Dali::Signal *arg1 = (Dali::Signal *)0; + void (*arg2)(Dali::GlWindow::WindowSize) = (void (*)(Dali::GlWindow::WindowSize))0; + + arg1 = (Dali::Signal *)jarg1; + arg2 = (void (*)(Dali::GlWindow::WindowSize))jarg2; + { + try + { + Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Connect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Disconnect(void *jarg1, void *jarg2) + { + Dali::Signal *arg1 = (Dali::Signal *)0; + void (*arg2)(Dali::GlWindow::WindowSize) = (void (*)(Dali::GlWindow::WindowSize))0; + + arg1 = (Dali::Signal *)jarg1; + arg2 = (void (*)(Dali::GlWindow::WindowSize))jarg2; + { + try + { + Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Disconnect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Emit(void *jarg1, void *jarg2) + { + Dali::Signal *arg1 = (Dali::Signal *)0; + Dali::GlWindow::WindowSize arg2; + Dali::GlWindow::WindowSize *argp2; + + arg1 = (Dali::Signal *)jarg1; + if (arg1 == nullptr) + { + DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr"); + return; + } + argp2 = (Dali::GlWindow::WindowSize *)jarg2; + if (!argp2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow::WindowSize", 0); + return; + } + arg2 = *argp2; + { + try + { + Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Emit(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlWindow_ResizedSignal() + { + void *jresult; + Dali::Signal *result = 0; + + { + try + { + result = (Dali::Signal *)new Dali::Signal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_delete_ResizedSignal(void *jarg1) + { + Dali::Signal *arg1 = (Dali::Signal *)0; + + arg1 = (Dali::Signal *)jarg1; + { + try + { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } + } + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-adaptor/input-method-context-wrap.cpp b/dali-csharp-binder/dali-adaptor/input-method-context-wrap.cpp new file mode 100755 index 00000000..fc7e131e --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/input-method-context-wrap.cpp @@ -0,0 +1,1931 @@ +/* + * Copyright (c) 2020 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include + +// INTERNAL INCLUDES +#include + +/* Callback for returning strings to C# without leaking memory */ +typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +// Signals + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Empty(Dali::Signal< void (Dali::InputMethodContext &) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::InputMethodContext &) > const *self){ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Connect(Dali::Signal< void (Dali::InputMethodContext &) > *self,void (*func)(Dali::InputMethodContext &)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::InputMethodContext &) > *self,void (*func)(Dali::InputMethodContext &)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Emit(Dali::Signal< void (Dali::InputMethodContext &) > *self,Dali::InputMethodContext &arg){ + self->Emit( arg ); +} + +SWIGINTERN bool Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Empty(Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > const *self){ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Connect(Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *self,Dali::InputMethodContext::CallbackData (*func)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *self,Dali::InputMethodContext::CallbackData (*func)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &)){ + self->Disconnect( func ); +} +SWIGINTERN Dali::InputMethodContext::CallbackData Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Emit(Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *self,Dali::InputMethodContext &arg1,Dali::InputMethodContext::EventData const &arg2){ + return self->Emit( arg1, arg2 ); +} + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (bool) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (bool) > const *self){ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (bool) > *self,void (*func)(bool)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (bool) > *self,void (*func)(bool)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (bool) > *self,bool arg){ + self->Emit( arg ); +} + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Empty(Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > const *self){ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Connect(Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *self,void (*func)(Dali::InputMethodContext::KeyboardType)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Disconnect(Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *self,void (*func)(Dali::InputMethodContext::KeyboardType)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Emit(Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *self,Dali::InputMethodContext::KeyboardType arg){ + self->Emit( arg ); +} + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_int_SP__Sg__Empty(Dali::Signal< void (int) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_int_SP__Sg__GetConnectionCount(Dali::Signal< void (int) > const *self){ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_int_SP__Sg__Connect(Dali::Signal< void (int) > *self,void (*func)(int)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_int_SP__Sg__Disconnect(Dali::Signal< void (int) > *self,void (*func)(int)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_int_SP__Sg__Emit(Dali::Signal< void (int) > *self,int arg){ + self->Emit( arg ); +} + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__Empty(Dali::Signal< void (std::string const &, std::string const &, std::string const &) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__GetConnectionCount(Dali::Signal< void (std::string const &, std::string const &, std::string const &) > const *self){ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__Connect(Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *self,void (*func)(std::string const &, std::string const &, std::string const &)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__Disconnect(Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *self,void (*func)(std::string const &, std::string const &, std::string const &)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__Emit(Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *self,std::string const &arg1,std::string const &arg2,std::string const &arg3){ + self->Emit( arg1, arg2, arg3 ); +} + +// Functions + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_InputMethodContext_SWIGUpcast(Dali::InputMethodContext *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_InputMethodContext_EventData__SWIG_0() { + void * jresult ; + Dali::InputMethodContext::EventData *eventData = 0 ; + + { + try { + eventData = (Dali::InputMethodContext::EventData *)new Dali::InputMethodContext::EventData(); + } CALL_CATCH_EXCEPTION(0); } + jresult = (void *)eventData; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_InputMethodContext_EventData__SWIG_1(int csEventType, char * csPredictiveString, int csCursorOffset, int csNumberOfChars) { + void * jresult ; + Dali::InputMethodContext::EventType eventType ; + std::string *predictiveString = 0 ; + int cursorOffset ; + int numberOfChars ; + Dali::InputMethodContext::EventData *eventData = 0 ; + + eventType = (Dali::InputMethodContext::EventType)csEventType; + if (!csPredictiveString) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string predictiveStringStr(csPredictiveString); + predictiveString = &predictiveStringStr; + cursorOffset = (int)csCursorOffset; + numberOfChars = (int)csNumberOfChars; + { + try { + eventData = (Dali::InputMethodContext::EventData *)new Dali::InputMethodContext::EventData(eventType,(std::string const &)*predictiveString,cursorOffset,numberOfChars); + } CALL_CATCH_EXCEPTION(0); } + jresult = (void *)eventData; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_predictiveString_set(void* csEventData, char* csPredictiveString) { + Dali::InputMethodContext::EventData *eventData = (Dali::InputMethodContext::EventData *) 0; + std::string *resultString = 0; + + eventData = (Dali::InputMethodContext::EventData *)csEventData; + if (!csPredictiveString) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return; + } + std::string pPredictiveString(csPredictiveString); + resultString = &pPredictiveString; + if (eventData) + { + (eventData)->predictiveString = *resultString; + } + + //argout typemap for const std::string& + +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_predictiveString_get(void* csEventData) { + char* jresult; + Dali::InputMethodContext::EventData *eventData = (Dali::InputMethodContext::EventData *) 0; + std::string *result = 0; + + eventData = (Dali::InputMethodContext::EventData *)csEventData; + result = (std::string *) & ((eventData)->predictiveString); + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_eventName_set(void* csEventData, int csEventType) { + Dali::InputMethodContext::EventData *eventData = (Dali::InputMethodContext::EventData *) 0; + Dali::InputMethodContext::EventType eventType; + + eventData = (Dali::InputMethodContext::EventData *)csEventData; + eventType = (Dali::InputMethodContext::EventType)csEventType; + if (eventData) + { + (eventData)->eventName = eventType; + } +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_eventName_get(void* csEventData) { + int jresult; + Dali::InputMethodContext::EventData *eventData = (Dali::InputMethodContext::EventData *) 0; + Dali::InputMethodContext::EventType eventType; + + eventData = (Dali::InputMethodContext::EventData *)csEventData; + eventType = (Dali::InputMethodContext::EventType) ((eventData)->eventName); + jresult = (int)eventType; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_cursorOffset_set(void* csEventData, int csCursorOffset) { + Dali::InputMethodContext::EventData *eventData = (Dali::InputMethodContext::EventData *) 0; + int pCursorOffset; + + eventData = (Dali::InputMethodContext::EventData *)csEventData; + pCursorOffset = (int)csCursorOffset; + if (eventData) + { + (eventData)->cursorOffset = pCursorOffset; + } +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_cursorOffset_get(void* csEventData) { + int jresult; + Dali::InputMethodContext::EventData *eventData = (Dali::InputMethodContext::EventData *) 0; + int pCursorOffset; + + eventData = (Dali::InputMethodContext::EventData *)csEventData; + pCursorOffset = (int) ((eventData)->cursorOffset); + jresult = pCursorOffset; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_numberOfChars_set(void * csEventData, int csNumberOfChars) { + Dali::InputMethodContext::EventData *eventData = (Dali::InputMethodContext::EventData *) 0; + int pNumberOfChars; + + eventData = (Dali::InputMethodContext::EventData *)csEventData; + pNumberOfChars = (int)csNumberOfChars; + if (eventData) + { + (eventData)->numberOfChars = pNumberOfChars; + } +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_numberOfChars_get(void * csEventData) { + int jresult; + Dali::InputMethodContext::EventData *eventData = (Dali::InputMethodContext::EventData *) 0; + int pNumberOfChars; + + eventData = (Dali::InputMethodContext::EventData *)csEventData; + pNumberOfChars = (int) ((eventData)->numberOfChars); + jresult = pNumberOfChars; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_InputMethodContext_EventData(void * csEventData) { + Dali::InputMethodContext::EventData *eventData = (Dali::InputMethodContext::EventData *) 0 ; + + eventData = (Dali::InputMethodContext::EventData *)csEventData; + { + try { + delete eventData; + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_InputMethodContext_CallbackData__SWIG_0() { + void * jresult ; + Dali::InputMethodContext::CallbackData *callbackData = 0 ; + + { + try { + callbackData = (Dali::InputMethodContext::CallbackData *)new Dali::InputMethodContext::CallbackData(); + } CALL_CATCH_EXCEPTION(0); } + jresult = (void *)callbackData; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_InputMethodContext_CallbackData__SWIG_1(unsigned int csUpdate, int csCursorPosition, char * csCurrentText, unsigned int csPreeditResetRequired) { + void * jresult ; + bool isUpdated ; + int cursorPosition ; + std::string *currentText = 0 ; + bool isPreeditResetRequired ; + Dali::InputMethodContext::CallbackData *result = 0 ; + + isUpdated = csUpdate ? true : false; + cursorPosition = (int)csCursorPosition; + if (!csCurrentText) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string currentTextStr(csCurrentText); + currentText = ¤tTextStr; + isPreeditResetRequired = csPreeditResetRequired ? true : false; + { + try { + result = (Dali::InputMethodContext::CallbackData *)new Dali::InputMethodContext::CallbackData(isUpdated,cursorPosition,(std::string const &)*currentText,isPreeditResetRequired); + } CALL_CATCH_EXCEPTION(0); } + jresult = (void *)result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_currentText_set(void * csCallbackData, char * csCurrentText) { + Dali::InputMethodContext::CallbackData *callbackData = (Dali::InputMethodContext::CallbackData *) 0 ; + std::string *currentText = 0 ; + + callbackData = (Dali::InputMethodContext::CallbackData *)csCallbackData; + if (!csCurrentText) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string currentTextStr(csCurrentText); + currentText = ¤tTextStr; + if (callbackData) (callbackData)->currentText = *currentText; + + //argout typemap for const std::string& + +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_currentText_get(void * csCallbackData) { + char * jresult ; + Dali::InputMethodContext::CallbackData *callbackData = (Dali::InputMethodContext::CallbackData *) 0 ; + std::string *currentText = 0 ; + + callbackData = (Dali::InputMethodContext::CallbackData *)csCallbackData; + currentText = (std::string *) & ((callbackData)->currentText); + jresult = SWIG_csharp_string_callback(currentText->c_str()); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_cursorPosition_set(void * csCallbackData, int csCursorPosition) { + Dali::InputMethodContext::CallbackData *callbackData = (Dali::InputMethodContext::CallbackData *) 0 ; + int cursorPosition ; + + callbackData = (Dali::InputMethodContext::CallbackData *)csCallbackData; + cursorPosition = (int)csCursorPosition; + if (callbackData) (callbackData)->cursorPosition = cursorPosition; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_cursorPosition_get(void * csCallbackData) { + int jresult ; + Dali::InputMethodContext::CallbackData *callbackData = (Dali::InputMethodContext::CallbackData *) 0 ; + int result; + + callbackData = (Dali::InputMethodContext::CallbackData *)csCallbackData; + result = (int) ((callbackData)->cursorPosition); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_update_set(void * csCallbackData, unsigned int csUpdate) { + Dali::InputMethodContext::CallbackData *callbackData = (Dali::InputMethodContext::CallbackData *) 0 ; + bool isUpdated ; + + callbackData = (Dali::InputMethodContext::CallbackData *)csCallbackData; + isUpdated = csUpdate ? true : false; + if (callbackData) (callbackData)->update = isUpdated; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_update_get(void * csCallbackData) { + unsigned int jresult ; + Dali::InputMethodContext::CallbackData *callbackData = (Dali::InputMethodContext::CallbackData *) 0 ; + bool isUpdated; + + callbackData = (Dali::InputMethodContext::CallbackData *)csCallbackData; + isUpdated = (bool) ((callbackData)->update); + jresult = isUpdated; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_preeditResetRequired_set(void * csCallbackData, unsigned int csPreeditResetRequired) { + Dali::InputMethodContext::CallbackData *callbackData = (Dali::InputMethodContext::CallbackData *) 0 ; + bool isPreeditResetRequired ; + + callbackData = (Dali::InputMethodContext::CallbackData *)csCallbackData; + isPreeditResetRequired = csPreeditResetRequired ? true : false; + if (callbackData) (callbackData)->preeditResetRequired = isPreeditResetRequired; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_preeditResetRequired_get(void * csCallbackData) { + unsigned int jresult ; + Dali::InputMethodContext::CallbackData *callbackData = (Dali::InputMethodContext::CallbackData *) 0 ; + bool isPreeditResetRequired; + + callbackData = (Dali::InputMethodContext::CallbackData *)csCallbackData; + isPreeditResetRequired = (bool) ((callbackData)->preeditResetRequired); + jresult = isPreeditResetRequired; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_InputMethodContext_CallbackData(void * csCallbackData) { + Dali::InputMethodContext::CallbackData *callbackData = (Dali::InputMethodContext::CallbackData *) 0 ; + + callbackData = (Dali::InputMethodContext::CallbackData *)csCallbackData; + { + try { + delete callbackData; + } CALL_CATCH_EXCEPTION(); } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_Finalize(void * csInputMethodContext) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + (inputMethodContext)->Finalize(); + } CALL_CATCH_EXCEPTION(); } +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_InputMethodContext__SWIG_0() { + void * jresult ; + Dali::InputMethodContext *inputMethodContext = 0 ; + + { + try { + inputMethodContext = (Dali::InputMethodContext *)new Dali::InputMethodContext(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)inputMethodContext; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_InputMethodContext(void * csInputMethodContext) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + delete inputMethodContext; + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_New() { + void * jresult ; + Dali::InputMethodContext inputMethodContext; + + { + try { + inputMethodContext = Dali::InputMethodContext::New( Dali::Stage::GetCurrent().GetRootLayer() ); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::InputMethodContext((const Dali::InputMethodContext &)inputMethodContext); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_InputMethodContext__SWIG_1(void * csInputMethodContext) { + void * jresult ; + Dali::InputMethodContext *inputMethodContext = 0 ; + Dali::InputMethodContext *result = 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + if (!inputMethodContext) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext const & type is null", 0); + return 0; + } + { + try { + result = (Dali::InputMethodContext *)new Dali::InputMethodContext((Dali::InputMethodContext const &)*inputMethodContext); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_Assign(void * csInputMethodContext, void * rInputMethodContext) { + void * jresult ; + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + Dali::InputMethodContext *assignedInputMethodContext = 0 ; + Dali::InputMethodContext *result = 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + assignedInputMethodContext = (Dali::InputMethodContext *)rInputMethodContext; + if (!assignedInputMethodContext) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext const & type is null", 0); + return 0; + } + { + try { + result = (Dali::InputMethodContext *) &(inputMethodContext)->operator =((Dali::InputMethodContext const &)*assignedInputMethodContext); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::InputMethodContext 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::InputMethodContext::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::InputMethodContext((const Dali::InputMethodContext &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_Activate(void * csInputMethodContext) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + (inputMethodContext)->Activate(); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_Deactivate(void * csInputMethodContext) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + (inputMethodContext)->Deactivate(); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_InputMethodContext_RestoreAfterFocusLost(void * csInputMethodContext) { + unsigned int jresult ; + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + bool status ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + status = (bool)((Dali::InputMethodContext const *)inputMethodContext)->RestoreAfterFocusLost(); + } CALL_CATCH_EXCEPTION(0); } + jresult = status; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetRestoreAfterFocusLost(void * csInputMethodContext, unsigned int csToggle) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + bool toggle ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + toggle = csToggle ? true : false; + { + try { + (inputMethodContext)->SetRestoreAfterFocusLost(toggle); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_Reset(void * csInputMethodContext) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + (inputMethodContext)->Reset(); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_NotifyCursorPosition(void * csInputMethodContext) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + (inputMethodContext)->NotifyCursorPosition(); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetCursorPosition(void * csInputMethodContext, unsigned int csCursorPosition) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + unsigned int cursorPosition ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + cursorPosition = (unsigned int)csCursorPosition; + { + try { + (inputMethodContext)->SetCursorPosition(cursorPosition); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_InputMethodContext_GetCursorPosition(void * csInputMethodContext) { + unsigned int jresult ; + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + unsigned int cursorPosition; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + cursorPosition = (unsigned int)((Dali::InputMethodContext const *)inputMethodContext)->GetCursorPosition(); + } CALL_CATCH_EXCEPTION(0); } + jresult = cursorPosition; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetSurroundingText(void * csInputMethodContext, char * csText) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + std::string *text = 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + if (!csText) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string textStr(csText); + text = &textStr; + { + try { + (inputMethodContext)->SetSurroundingText((std::string const &)*text); + } CALL_CATCH_EXCEPTION(); } + + //argout typemap for const std::string& + +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_InputMethodContext_GetSurroundingText(void * csInputMethodContext) { + char * jresult ; + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + std::string *text = 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + text = (std::string *) &((Dali::InputMethodContext const *)inputMethodContext)->GetSurroundingText(); + } CALL_CATCH_EXCEPTION(0); } + jresult = SWIG_csharp_string_callback(text->c_str()); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_NotifyTextInputMultiLine(void * csInputMethodContext, unsigned int csMultiLine) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + bool isMultiLine ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + isMultiLine = csMultiLine ? true : false; + { + try { + (inputMethodContext)->NotifyTextInputMultiLine(isMultiLine); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_GetTextDirection(void * csInputMethodContext) { + int jresult ; + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + Dali::InputMethodContext::TextDirection direction; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + direction = (Dali::InputMethodContext::TextDirection)(inputMethodContext)->GetTextDirection(); + } CALL_CATCH_EXCEPTION(0); } + jresult = (int)direction; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_GetInputMethodArea(void * csInputMethodContext) { + void * jresult ; + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + Dali::Rect< int > area; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + area = (inputMethodContext)->GetInputMethodArea(); + } CALL_CATCH_EXCEPTION(0); } + jresult = new Dali::Rect< int >((const Dali::Rect< int > &)area); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_ApplyOptions(void * csInputMethodContext, void * csInputMethodOptions) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + Dali::InputMethodOptions *inputMethodOptions = 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + inputMethodOptions = (Dali::InputMethodOptions *)csInputMethodOptions; + if (!inputMethodOptions) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InputMethodOptions const & type is null", 0); + return ; + } + { + try { + (inputMethodContext)->ApplyOptions((Dali::InputMethodOptions const &)*inputMethodOptions); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetInputPanelUserData(void * csInputMethodContext, char * csData) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + std::string *data = 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + if (!csData) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string dataStr(csData); + data = &dataStr; + { + try { + (inputMethodContext)->SetInputPanelData((std::string const &)*data); + } CALL_CATCH_EXCEPTION(); } + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_GetInputPanelUserData(void * csInputMethodContext, char** csData) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + std::string *data = 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + + //typemap in + std::string temp; + data = &temp; + + { + try { + (inputMethodContext)->GetInputPanelData(*data); + } CALL_CATCH_EXCEPTION(); } + + //Typemap argout in c++ file. + //This will convert c++ string to c# string + *csData = SWIG_csharp_string_callback(data->c_str()); + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_GetInputPanelState(void * csInputMethodContext) { + int jresult ; + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + Dali::InputMethodContext::State result; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + result = (Dali::InputMethodContext::State)(inputMethodContext)->GetInputPanelState(); + } CALL_CATCH_EXCEPTION(0); } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetReturnKeyState(void * csInputMethodContext, unsigned int csVisible) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + bool isVisible ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + isVisible = csVisible ? true : false; + { + try { + (inputMethodContext)->SetReturnKeyState(isVisible); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_AutoEnableInputPanel(void * csInputMethodContext, unsigned int csEnabled) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + bool isEnabled ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + isEnabled = csEnabled ? true : false; + { + try { + (inputMethodContext)->AutoEnableInputPanel(isEnabled); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_ShowInputPanel(void * csInputMethodContext) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + (inputMethodContext)->ShowInputPanel(); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_HideInputPanel(void * csInputMethodContext) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + (inputMethodContext)->HideInputPanel(); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_GetKeyboardType(void * csInputMethodContext) { + int jresult ; + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + Dali::InputMethodContext::KeyboardType type; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + type = (Dali::InputMethodContext::KeyboardType)(inputMethodContext)->GetKeyboardType(); + } CALL_CATCH_EXCEPTION(0); } + jresult = (int)type; + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_InputMethodContext_GetInputPanelLocale(void * csInputMethodContext) { + char * jresult ; + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + std::string locale; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + locale = (inputMethodContext)->GetInputPanelLocale(); + } CALL_CATCH_EXCEPTION(0); } + jresult = SWIG_csharp_string_callback((&locale)->c_str()); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_AllowTextPrediction(void * csInputMethodContext, unsigned int csPrediction) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + bool prediction ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + prediction = csPrediction ? true : false; + { + try { + (inputMethodContext)->AllowTextPrediction(prediction); + } CALL_CATCH_EXCEPTION(); } +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_InputMethodContext_IsTextPredictionAllowed(void * csInputMethodContext) { + unsigned int jresult ; + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + bool prediction; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + prediction = (bool)((Dali::InputMethodContext const *)inputMethodContext)->IsTextPredictionAllowed(); + } CALL_CATCH_EXCEPTION(0); } + jresult = prediction; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetMIMEType(void * csInputMethodContext, char * csMimeTypes) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + std::string *mimeTypes = 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + if (!csMimeTypes) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string mimeTypesString(csMimeTypes); + mimeTypes = &mimeTypesString; + { + try { + (inputMethodContext)->SetContentMIMETypes((std::string const &)*mimeTypes); + } CALL_CATCH_EXCEPTION(); } + + //argout typemap for const std::string& + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetInputPanelLanguage(void * csInputMethodContext, int csLanguage) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + Dali::InputMethodContext::InputPanelLanguage language ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + if (inputMethodContext == nullptr) { + DALI_LOG_ERROR("[ERR] inputMethodContext == nullptr"); + return; + } + + language = (Dali::InputMethodContext::InputPanelLanguage)csLanguage; + { + try { + (inputMethodContext)->SetInputPanelLanguage(language); + } CALL_CATCH_EXCEPTION(); } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_GetInputPanelLanguage(void * csInputMethodContext) { + int jresult ; + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + Dali::InputMethodContext::InputPanelLanguage language; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + if (inputMethodContext == nullptr) { + DALI_LOG_ERROR("[ERR] inputMethodContext == nullptr"); + return false; + } + { + try { + language = (Dali::InputMethodContext::InputPanelLanguage)(inputMethodContext)->GetInputPanelLanguage(); + } CALL_CATCH_EXCEPTION(0); } + jresult = (int)language; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetInputPanelPosition(void * csInputMethodContext, unsigned int csXCoord, unsigned int csYCoord) { + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + unsigned int x ; + unsigned int y ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + x = (unsigned int)csXCoord; + y = (unsigned int)csYCoord; + { + try { + (inputMethodContext)->SetInputPanelPosition(x, y); + } CALL_CATCH_EXCEPTION(); } +} + + +// Signals +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_ActivatedSignal(void * csInputMethodContext) { + void * jresult ; + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + Dali::InputMethodContext::ActivatedSignalType *type = 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + type = (Dali::InputMethodContext::ActivatedSignalType *) &(inputMethodContext)->ActivatedSignal(); + } CALL_CATCH_EXCEPTION(0); } + jresult = (void *)type; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_EventReceivedSignal(void * csInputMethodContext) { + void * jresult ; + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + Dali::InputMethodContext::KeyboardEventSignalType *type = 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + type = (Dali::InputMethodContext::KeyboardEventSignalType *) &(inputMethodContext)->EventReceivedSignal(); + } CALL_CATCH_EXCEPTION(0); } + jresult = (void *)type; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_StatusChangedSignal(void * csInputMethodContext) { + void * jresult ; + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + Dali::InputMethodContext::StatusSignalType *type = 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + type = (Dali::InputMethodContext::StatusSignalType *) &(inputMethodContext)->StatusChangedSignal(); + } CALL_CATCH_EXCEPTION(0); } + jresult = (void *)type; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_ResizedSignal(void * csInputMethodContext) { + void * jresult ; + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + Dali::InputMethodContext::KeyboardResizedSignalType *type = 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + type = (Dali::InputMethodContext::KeyboardResizedSignalType *) &(inputMethodContext)->ResizedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)type; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_LanguageChangedSignal(void * csInputMethodContext) { + void * jresult ; + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + Dali::InputMethodContext::LanguageChangedSignalType *type = 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + type = (Dali::InputMethodContext::LanguageChangedSignalType *) &(inputMethodContext)->LanguageChangedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)type; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_KeyboardTypeChangedSignal(void * csInputMethodContext) { + void * jresult ; + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + Dali::InputMethodContext::KeyboardTypeSignalType *type = 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + type = (Dali::InputMethodContext::KeyboardTypeSignalType *) &(inputMethodContext)->KeyboardTypeChangedSignal(); + } CALL_CATCH_EXCEPTION(0); } + jresult = (void *)type; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_ContentReceivedSignal(void * csInputMethodContext) { + void * jresult ; + Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; + Dali::InputMethodContext::ContentReceivedSignalType *type = 0 ; + + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + { + try { + type = (Dali::InputMethodContext::ContentReceivedSignalType *) &(inputMethodContext)->ContentReceivedSignal(); + } CALL_CATCH_EXCEPTION(0); } + jresult = (void *)type; + return jresult; +} + +// ActivatedSignalType +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Empty(void * csSignal) { + unsigned int jresult ; + Dali::Signal< void (Dali::InputMethodContext &) > *signal = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ; + bool result; + + signal = (Dali::Signal< void (Dali::InputMethodContext &) > *)csSignal; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Empty((Dali::Signal< void (Dali::InputMethodContext &) > const *)signal); + } CALL_CATCH_EXCEPTION(0); } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActivatedSignalType_GetConnectionCount(void * csSignal) { + unsigned long jresult ; + Dali::Signal< void (Dali::InputMethodContext &) > *signal = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ; + std::size_t result; + + signal = (Dali::Signal< void (Dali::InputMethodContext &) > *)csSignal; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::InputMethodContext &) > const *)signal); + } CALL_CATCH_EXCEPTION(0); } + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Connect(void * csSignal, void * csInputMethodContext) { + Dali::Signal< void (Dali::InputMethodContext &) > *signal = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ; + void (*inputMethodContext)(Dali::InputMethodContext &) = (void (*)(Dali::InputMethodContext &)) 0 ; + + signal = (Dali::Signal< void (Dali::InputMethodContext &) > *)csSignal; + inputMethodContext = (void (*)(Dali::InputMethodContext &))csInputMethodContext; + { + try { + Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Connect(signal,inputMethodContext); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Disconnect(void * csSignal, void * csInputMethodContext) { + Dali::Signal< void (Dali::InputMethodContext &) > *signal = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ; + void (*inputMethodContext)(Dali::InputMethodContext &) = (void (*)(Dali::InputMethodContext &)) 0 ; + + signal = (Dali::Signal< void (Dali::InputMethodContext &) > *)csSignal; + inputMethodContext = (void (*)(Dali::InputMethodContext &))csInputMethodContext; + { + try { + Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Disconnect(signal,inputMethodContext); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Emit(void * csSignal, void * csInputMethodContext) { + Dali::Signal< void (Dali::InputMethodContext &) > *signal = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ; + Dali::InputMethodContext *inputMethodContext = 0 ; + + signal = (Dali::Signal< void (Dali::InputMethodContext &) > *)csSignal; + inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; + if (!inputMethodContext) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext & type is null", 0); + return ; + } + { + try { + Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Emit(signal,*inputMethodContext); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActivatedSignalType() { + void * jresult ; + Dali::Signal< void (Dali::InputMethodContext &) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::InputMethodContext &) > *)new Dali::Signal< void (Dali::InputMethodContext &) >(); + } CALL_CATCH_EXCEPTION(0); } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActivatedSignalType(void * csSignal) { + Dali::Signal< void (Dali::InputMethodContext &) > *signal = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ; + + signal = (Dali::Signal< void (Dali::InputMethodContext &) > *)csSignal; + { + try { + delete signal; + } CALL_CATCH_EXCEPTION(); } +} + +// KeyboardEventSignalType +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Empty(void * csEventData) { + unsigned int jresult ; + Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)csEventData; + { + try { + result = (bool)Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Empty((Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_GetConnectionCount(void * csEventData) { + unsigned long jresult ; + Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)csEventData; + { + try { + result = Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); } + jresult = (unsigned long)result; + return jresult; +} + +typedef Dali::InputMethodContext::CallbackData* (SWIGSTDCALL* SWIG_CallbackEventReceived)(Dali::InputMethodContext *, Dali::InputMethodContext::EventData *); +SWIG_CallbackEventReceived swig_callbackOnEventReceived; + +Dali::InputMethodContext::CallbackData OnEventReceivedCallback(Dali::InputMethodContext inputMethodContext, Dali::InputMethodContext::EventData eventData) +{ + Dali::InputMethodContext::CallbackData *callbackDataP; + Dali::InputMethodContext::CallbackData callbackData; + Dali::InputMethodContext *inputMethodContextP = NULL; + Dali::InputMethodContext::EventData *eventDataP = NULL; + + if (inputMethodContext) + { + inputMethodContextP = (Dali::InputMethodContext *)&inputMethodContext; + } + + eventDataP = (Dali::InputMethodContext::EventData *)&eventData; + + callbackDataP = (Dali::InputMethodContext::CallbackData *)swig_callbackOnEventReceived(inputMethodContextP, eventDataP); + if (callbackDataP) + { + callbackData = *callbackDataP; + } + + return callbackData; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Connect(void * jarg1, SWIG_CallbackEventReceived callbackOnEventReceived) { + + swig_callbackOnEventReceived = callbackOnEventReceived; + + Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ; + Dali::InputMethodContext::CallbackData (*arg2)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &)) 0 ; + + arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1; + arg2 = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &))OnEventReceivedCallback; + { + try { + Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Disconnect(void * jarg1, SWIG_CallbackEventReceived callbackOnEventReceived) { + + swig_callbackOnEventReceived = callbackOnEventReceived; + + Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ; + Dali::InputMethodContext::CallbackData (*arg2)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &)) 0 ; + + arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1; + arg2 = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &))OnEventReceivedCallback; + { + try { + Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); } +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Emit(void * jarg1, void * jarg2, void * jarg3) { + void * jresult ; + Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ; + Dali::InputMethodContext *arg2 = 0 ; + Dali::InputMethodContext::EventData *arg3 = 0 ; + Dali::InputMethodContext::CallbackData result; + + arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1; + arg2 = (Dali::InputMethodContext *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext & type is null", 0); + return 0; + } + arg3 = (Dali::InputMethodContext::EventData *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext::EventData const & type is null", 0); + return 0; + } + { + try { + result = Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Emit(arg1,*arg2,(Dali::InputMethodContext::EventData const &)*arg3); + } CALL_CATCH_EXCEPTION(0); } + jresult = new Dali::InputMethodContext::CallbackData((const Dali::InputMethodContext::CallbackData &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyboardEventSignalType() { + void * jresult ; + Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *result = 0 ; + + { + try { + result = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)new Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) >(); + } CALL_CATCH_EXCEPTION(0); } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyboardEventSignalType(void * jarg1) { + Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ; + + arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); } +} + + +// VoidSignalType +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignalType() { + void * jresult ; + Dali::Signal< void () > *result = 0 ; + + { + try { + result = (Dali::Signal< void () > *)new Dali::Signal< void () >(); + } CALL_CATCH_EXCEPTION(0); } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignalType(void * jarg1) { + Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; + + arg1 = (Dali::Signal< void () > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignalType_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void () > *)jarg1; + { + try { + result = (bool)((Dali::Signal< void () > const *)arg1)->Empty(); + } CALL_CATCH_EXCEPTION(0); } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignalType_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void () > *)jarg1; + { + try { + result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount(); + } CALL_CATCH_EXCEPTION(0); } + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Connect__SWIG_0(void * jarg1, void * jarg2) { + Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; + void (*arg2)() = (void (*)()) 0 ; + + arg1 = (Dali::Signal< void () > *)jarg1; + arg2 = (void (*)())jarg2; + { + try { + (arg1)->Connect(arg2); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; + void (*arg2)() = (void (*)()) 0 ; + + arg1 = (Dali::Signal< void () > *)jarg1; + arg2 = (void (*)())jarg2; + { + try { + (arg1)->Disconnect(arg2); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) { + Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; + Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ; + Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ; + + arg1 = (Dali::Signal< void () > *)jarg1; + arg2 = (Dali::ConnectionTrackerInterface *)jarg2; + arg3 = (Dali::FunctorDelegate *)jarg3; + { + try { + (arg1)->Connect(arg2,arg3); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Emit(void * jarg1) { + Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; + + arg1 = (Dali::Signal< void () > *)jarg1; + { + try { + (arg1)->Emit(); + } CALL_CATCH_EXCEPTION(); } +} + +//StatusSignalType +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StatusSignalType_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (bool) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StatusSignalType_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (bool) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); } + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StatusSignalType_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ; + void (*arg2)(bool) = (void (*)(bool)) 0 ; + + arg1 = (Dali::Signal< void (bool) > *)jarg1; + arg2 = (void (*)(bool))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StatusSignalType_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ; + void (*arg2)(bool) = (void (*)(bool)) 0 ; + + arg1 = (Dali::Signal< void (bool) > *)jarg1; + arg2 = (void (*)(bool))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StatusSignalType_Emit(void * jarg1, unsigned int jarg2) { + Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ; + bool arg2 ; + + arg1 = (Dali::Signal< void (bool) > *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StatusSignalType() { + void * jresult ; + Dali::Signal< void (bool) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >(); + } CALL_CATCH_EXCEPTION(0); } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StatusSignalType(void * jarg1) { + Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ; + + arg1 = (Dali::Signal< void (bool) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); } +} + +//KeyboardTypeSignalType +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Empty((Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); } + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ; + void (*arg2)(Dali::InputMethodContext::KeyboardType) = (void (*)(Dali::InputMethodContext::KeyboardType)) 0 ; + + arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1; + arg2 = (void (*)(Dali::InputMethodContext::KeyboardType))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ; + void (*arg2)(Dali::InputMethodContext::KeyboardType) = (void (*)(Dali::InputMethodContext::KeyboardType)) 0 ; + + arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1; + arg2 = (void (*)(Dali::InputMethodContext::KeyboardType))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Emit(void * jarg1, int jarg2) { + Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ; + Dali::InputMethodContext::KeyboardType arg2 ; + + arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1; + arg2 = (Dali::InputMethodContext::KeyboardType)jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Emit(arg1,arg2); + } CALL_CATCH_EXCEPTION(); } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyboardTypeSignalType() { + void * jresult ; + Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)new Dali::Signal< void (Dali::InputMethodContext::KeyboardType) >(); + } CALL_CATCH_EXCEPTION(0); } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyboardTypeSignalType(void * jarg1) { + Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); } +} + +//LanguageChangedSignalType + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (int) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_int_SP__Sg__Empty((Dali::Signal< void (int) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (int) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_int_SP__Sg__GetConnectionCount((Dali::Signal< void (int) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; + void (*arg2)(int) = (void (*)(int)) 0 ; + + arg1 = (Dali::Signal< void (int) > *)jarg1; + arg2 = (void (*)(int))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_int_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; + void (*arg2)(int) = (void (*)(int)) 0 ; + + arg1 = (Dali::Signal< void (int) > *)jarg1; + arg2 = (void (*)(int))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_int_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Emit(void * jarg1, int jarg2) { + Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; + int arg2 ; + + arg1 = (Dali::Signal< void (int) > *)jarg1; + arg2 = (int)jarg2; + { + try { + Dali_Signal_Sl_void_Sp_int_SP__Sg__Emit(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LanguageChangedSignalType() { + void * jresult ; + Dali::Signal< void (int) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (int) > *)new Dali::Signal< void (int) >(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LanguageChangedSignalType(void * jarg1) { + Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; + + arg1 = (Dali::Signal< void (int) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +//KeyboardTypeSignalType + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (int) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_int_SP__Sg__Empty((Dali::Signal< void (int) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (int) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_int_SP__Sg__GetConnectionCount((Dali::Signal< void (int) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; + void (*arg2)(int) = (void (*)(int)) 0 ; + + arg1 = (Dali::Signal< void (int) > *)jarg1; + arg2 = (void (*)(int))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_int_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; + void (*arg2)(int) = (void (*)(int)) 0 ; + + arg1 = (Dali::Signal< void (int) > *)jarg1; + arg2 = (void (*)(int))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_int_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Emit(void * jarg1, int jarg2) { + Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; + int arg2 ; + + arg1 = (Dali::Signal< void (int) > *)jarg1; + arg2 = (int)jarg2; + { + try { + Dali_Signal_Sl_void_Sp_int_SP__Sg__Emit(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyboardResizedSignalType() { + void * jresult ; + Dali::Signal< void (int) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (int) > *)new Dali::Signal< void (int) >(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyboardResizedSignalType(void * jarg1) { + Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; + + arg1 = (Dali::Signal< void (int) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +//ContentReceivedSignalType + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ContentReceivedSignalType_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__Empty((Dali::Signal< void (std::string const &, std::string const &, std::string const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ContentReceivedSignalType_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__GetConnectionCount((Dali::Signal< void (std::string const &, std::string const &, std::string const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ContentReceivedSignalType_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *) 0 ; + void (*arg2)(std::string const &, std::string const &, std::string const &) = (void (*)(std::string const &, std::string const &, std::string const &)) 0 ; + + arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *)jarg1; + arg2 = (void (*)(std::string const &, std::string const &, std::string const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ContentReceivedSignalType_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *) 0 ; + void (*arg2)(std::string const &, std::string const &, std::string const &) = (void (*)(std::string const &, std::string const &, std::string const &)) 0 ; + + arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *)jarg1; + arg2 = (void (*)(std::string const &, std::string const &, std::string const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ContentReceivedSignalType_Emit(void * jarg1, char * jarg2, char * jarg3, char * jarg4) { + Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *) 0 ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string *arg4 = 0 ; + + arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *)jarg1; + std::string arg2_str(jarg2); + arg2 = &arg2_str; + std::string arg3_str(jarg3); + arg3 = &arg3_str; + std::string arg4_str(jarg4); + arg4 = &arg4_str; + { + try { + Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__Emit(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ContentReceivedSignalType() { + void * jresult ; + Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *)new Dali::Signal< void (std::string const &, std::string const &, std::string const &) >(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ContentReceivedSignalType(void * jarg1) { + Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *) 0 ; + + arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/dali-adaptor/input-method-options-wrap.cpp b/dali-csharp-binder/dali-adaptor/input-method-options-wrap.cpp new file mode 100755 index 00000000..46d22b88 --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/input-method-options-wrap.cpp @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2017 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_InputMethodOptions() { + void * jresult ; + Dali::InputMethodOptions *result = 0 ; + + { + try { + result = (Dali::InputMethodOptions *)new Dali::InputMethodOptions(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_InputMethodOptions_IsPassword(void * jarg1) { + unsigned int jresult ; + Dali::InputMethodOptions *arg1 = (Dali::InputMethodOptions *) 0 ; + bool result; + + arg1 = (Dali::InputMethodOptions *)jarg1; + { + try { + result = (bool)(arg1)->IsPassword(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodOptions_ApplyProperty(void * jarg1, void * jarg2) { + Dali::InputMethodOptions *arg1 = (Dali::InputMethodOptions *) 0 ; + Dali::Property::Map *arg2 = 0 ; + + arg1 = (Dali::InputMethodOptions *)jarg1; + arg2 = (Dali::Property::Map *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); + return ; + } + { + try { + (arg1)->ApplyProperty((Dali::Property::Map const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodOptions_RetrieveProperty(void * jarg1, void * jarg2) { + Dali::InputMethodOptions *arg1 = (Dali::InputMethodOptions *) 0 ; + Dali::Property::Map *arg2 = 0 ; + + arg1 = (Dali::InputMethodOptions *)jarg1; + arg2 = (Dali::Property::Map *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0); + return ; + } + { + try { + (arg1)->RetrieveProperty(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_InputMethodOptions(void * jarg1) { + Dali::InputMethodOptions *arg1 = (Dali::InputMethodOptions *) 0 ; + + arg1 = (Dali::InputMethodOptions *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/dali-adaptor/key-grab-wrap.cpp b/dali-csharp-binder/dali-adaptor/key-grab-wrap.cpp new file mode 100755 index 00000000..ce436976 --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/key-grab-wrap.cpp @@ -0,0 +1,157 @@ +/* + * Copyright (c) 2017 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include +#include +#include + +// INTERNAL INCLUDES +#include + + +#ifdef TIZEN_BUILD +#ifdef ECORE_WL2 +#include +#else +#include +#endif +#endif + +#undef LOG +//#define LOG DALI_LOG_ERROR +#define LOG(a...) + + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GrabKeyTopmost(void * window, int daliKey) +{ + Dali::Window *_win = (Dali::Window *)window; + bool ret; + + LOG("CSharp_Dali_GrabKeyTopmost() [DP1] window=%d, dalikey=%d", window, daliKey); + + { + try { + ret = Dali::KeyGrab::GrabKeyTopmost(*_win, (Dali::KEY)daliKey); + } CALL_CATCH_EXCEPTION(0); + } + + + LOG("CSharp_Dali_GrabKeyTopmost() [DP2] ret=%d", ret); + + return ret; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_UngrabKeyTopmost(void * window, int daliKey) +{ + Dali::Window *_win = (Dali::Window *)window; + bool ret; + + LOG("CSharp_Dali_UngrabKeyTopmost() [DP1] window=%d, dalikey=%d", window, daliKey); + + { + try { + ret = Dali::KeyGrab::UngrabKeyTopmost(*_win, (Dali::KEY)daliKey); + } CALL_CATCH_EXCEPTION(0); + } + + + LOG("CSharp_Dali_UngrabKeyTopmost() [DP2] ret=%d", ret); + + return ret; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GrabKey(void * window, int daliKey, int grabMode) +{ + Dali::Window *_win = (Dali::Window *)window; + bool ret; + + LOG("CSharp_Dali_GrabKey() [DP1] window=%d, dalikey=%d, grabmode=%d", window, daliKey, grabMode); + + { + try { + ret = Dali::KeyGrab::GrabKey(*_win, (Dali::KEY)daliKey, (Dali::KeyGrab::KeyGrabMode)grabMode); + } CALL_CATCH_EXCEPTION(0); + } + + + DALI_LOG_ERROR("CSharp_Dali_GrabKey() [DP2] ret=%d", ret); + + return ret; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_UngrabKey(void * window, int daliKey) +{ + Dali::Window *_win = (Dali::Window *)window; + bool ret; + + LOG("CSharp_Dali_UngrabKey() [DP1] window=%d, dalikey=%d", window, daliKey); + + { + try { + ret = Dali::KeyGrab::UngrabKey(*_win, (Dali::KEY)daliKey); + } CALL_CATCH_EXCEPTION(0); + } + + + LOG("CSharp_Dali_UngrabKey() [DP2] ret=%d", ret); + + return ret; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetNativeWindowHandler( void* window ) +{ + Dali::Window *_win = (Dali::Window *)window; + void * ret = NULL; + + LOG("CSharp_Dali_GetNativeWindowHandler() [DP1] window=%d", window); + + { + Dali::Any result; + try { + result = _win->GetNativeHandle(); +#ifdef TIZEN_BUILD +#ifdef ECORE_WL2 + Ecore_Wl2_Window * ecore_win = Dali::AnyCast(result); +#else + Ecore_Wl_Window * ecore_win = Dali::AnyCast(result); +#endif +#endif + ret = (void*)ecore_win; + + } CALL_CATCH_EXCEPTION(NULL); + } + + if(ret != NULL) + { + LOG("CSharp_Dali_GetNativeWindowHandler() [DP2] ret=%d", ret); + } + + return ret; +} + + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/dali-adaptor/keyboard-wrap.cpp b/dali-csharp-binder/dali-adaptor/keyboard-wrap.cpp new file mode 100755 index 00000000..6be4df03 --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/keyboard-wrap.cpp @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2018 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include +#include + +// INTERNAL INCLUDES +#include + +#ifdef TIZEN_BUILD +#ifdef ECORE_WL2 +#include +#else +#include +#endif +#endif + +#undef LOG +//#define LOG DALI_LOG_ERROR +#define LOG(a...) + + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Keyboard_SetRepeatInfo(float rate, float delay) +{ + bool ret; + + LOG("CSharp_Dali_Keyboard_SetRepeatInfo() [DP1] rate=%f, delay=%f", rate, delay); + + { + try { + ret = Dali::Keyboard::SetRepeatInfo(rate, delay); + } CALL_CATCH_EXCEPTION(0); + } + + + LOG("CSharp_Dali_Keyboard_SetRepeatInfo() [DP2] ret=%d", ret); + + return ret; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Keyboard_GetRepeatInfo(float& rate, float& delay) +{ + bool ret; + + LOG("CSharp_Dali_Keyboard_GetRepeatInfo() [DP1] rate=%f, delay=%f", rate, delay); + + { + try { + ret = Dali::Keyboard::GetRepeatInfo(rate, delay); + } CALL_CATCH_EXCEPTION(0); + } + + + LOG("CSharp_Dali_Keyboard_GetRepeatInfo() [DP2] ret=%d", ret); + + return ret; +} + + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/dali-adaptor/native-image-queue-wrap.cpp b/dali-csharp-binder/dali-adaptor/native-image-queue-wrap.cpp new file mode 100644 index 00000000..78c7b949 --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/native-image-queue-wrap.cpp @@ -0,0 +1,112 @@ +/* + * Copyright (c) 2021 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + +struct NativeImageSourceQueuePtrHandle +{ + Dali::NativeImageSourceQueuePtr Ptr; +}; + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_NativeImageQueuePtr(unsigned int width, unsigned int height, int colorFormat) +{ + void* jresult; + NativeImageSourceQueuePtrHandle* queue = new NativeImageSourceQueuePtrHandle(); + { + try { + queue->Ptr = Dali::NativeImageSourceQueue::New(width, height, (Dali::NativeImageSourceQueue::ColorFormat)colorFormat); + } + CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)queue; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageQueue_GetPtr(void* nuiqueue) +{ + void* jresult; + NativeImageSourceQueuePtrHandle* queue = (NativeImageSourceQueuePtrHandle*)nuiqueue; + jresult = (void*)(queue->Ptr.Get()); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImageQueuePtr(void* nuiqueue) +{ + NativeImageSourceQueuePtrHandle* queue = (NativeImageSourceQueuePtrHandle*)nuiqueue; + { + try { + delete queue; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageQueue_CanDequeueBuffer(void* nuiqueue) +{ + bool jresult; + Dali::NativeImageSourceQueue* queue = (Dali::NativeImageSourceQueue*)nuiqueue; + { + try { + jresult = queue->CanDequeueBuffer(); + } + CALL_CATCH_EXCEPTION(0); + } + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageQueue_DequeueBuffer(void* nuiqueue, int* jwidth, int* jheight, int* jstride) +{ + void* jresult; + Dali::NativeImageSourceQueue* queue = (Dali::NativeImageSourceQueue*)nuiqueue; + uint32_t* width = (uint32_t*)(jwidth); + uint32_t* height = (uint32_t*)(jheight); + uint32_t* stride = (uint32_t*)(jstride); + { + try { + jresult = (void *)queue->DequeueBuffer( *width, *height, *stride ); + } + CALL_CATCH_EXCEPTION(0); + } + return jresult; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageQueue_EnqueueBuffer(void* nuiqueue, void* jbuffer) +{ + bool jresult; + Dali::NativeImageSourceQueue* queue = (Dali::NativeImageSourceQueue*)nuiqueue; + uint8_t* buffer = (uint8_t*)jbuffer; + { + try { + jresult = queue->EnqueueBuffer(buffer); + } + CALL_CATCH_EXCEPTION(0); + } + return jresult; +} + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/dali-adaptor/tts-player-wrap.cpp b/dali-csharp-binder/dali-adaptor/tts-player-wrap.cpp new file mode 100755 index 00000000..2f364285 --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/tts-player-wrap.cpp @@ -0,0 +1,357 @@ +/* + * Copyright (c) 2017 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__Empty(Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > const *self){ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__Connect(Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *self,void (*func)(Dali::TtsPlayer::State const,Dali::TtsPlayer::State const)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__Disconnect(Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *self,void (*func)(Dali::TtsPlayer::State const,Dali::TtsPlayer::State const)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__Emit(Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *self,Dali::TtsPlayer::State const arg1,Dali::TtsPlayer::State const arg2){ + self->Emit( arg1, arg2 ); +} + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TtsPlayer_SWIGUpcast(Dali::TtsPlayer *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TtsPlayer__SWIG_0() { + void * jresult ; + Dali::TtsPlayer *result = 0 ; + + { + try { + result = (Dali::TtsPlayer *)new Dali::TtsPlayer(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TtsPlayer_Get__SWIG_0(int jarg1) { + void * jresult ; + Dali::TtsPlayer::Mode arg1 ; + Dali::TtsPlayer result; + + arg1 = (Dali::TtsPlayer::Mode)jarg1; + { + try { + result = Dali::TtsPlayer::Get(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::TtsPlayer((const Dali::TtsPlayer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TtsPlayer_Get__SWIG_1() { + void * jresult ; + Dali::TtsPlayer result; + + { + try { + result = Dali::TtsPlayer::Get(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::TtsPlayer((const Dali::TtsPlayer &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TtsPlayer(void * jarg1) { + Dali::TtsPlayer *arg1 = (Dali::TtsPlayer *) 0 ; + + arg1 = (Dali::TtsPlayer *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TtsPlayer__SWIG_1(void * jarg1) { + void * jresult ; + Dali::TtsPlayer *arg1 = 0 ; + Dali::TtsPlayer *result = 0 ; + + arg1 = (Dali::TtsPlayer *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TtsPlayer const & type is null", 0); + return 0; + } + { + try { + result = (Dali::TtsPlayer *)new Dali::TtsPlayer((Dali::TtsPlayer const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TtsPlayer_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::TtsPlayer *arg1 = (Dali::TtsPlayer *) 0 ; + Dali::TtsPlayer *arg2 = 0 ; + Dali::TtsPlayer *result = 0 ; + + arg1 = (Dali::TtsPlayer *)jarg1; + arg2 = (Dali::TtsPlayer *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TtsPlayer const & type is null", 0); + return 0; + } + { + try { + result = (Dali::TtsPlayer *) &(arg1)->operator =((Dali::TtsPlayer const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TtsPlayer_Play(void * jarg1, char * jarg2) { + Dali::TtsPlayer *arg1 = (Dali::TtsPlayer *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::TtsPlayer *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + (arg1)->Play((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TtsPlayer_Stop(void * jarg1) { + Dali::TtsPlayer *arg1 = (Dali::TtsPlayer *) 0 ; + + arg1 = (Dali::TtsPlayer *)jarg1; + { + try { + (arg1)->Stop(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TtsPlayer_Pause(void * jarg1) { + Dali::TtsPlayer *arg1 = (Dali::TtsPlayer *) 0 ; + + arg1 = (Dali::TtsPlayer *)jarg1; + { + try { + (arg1)->Pause(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TtsPlayer_Resume(void * jarg1) { + Dali::TtsPlayer *arg1 = (Dali::TtsPlayer *) 0 ; + + arg1 = (Dali::TtsPlayer *)jarg1; + { + try { + (arg1)->Resume(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TtsPlayer_GetState(void * jarg1) { + int jresult ; + Dali::TtsPlayer *arg1 = (Dali::TtsPlayer *) 0 ; + Dali::TtsPlayer::State result; + + arg1 = (Dali::TtsPlayer *)jarg1; + { + try { + result = (Dali::TtsPlayer::State)(arg1)->GetState(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TtsPlayer_StateChangedSignal(void * jarg1) { + void * jresult ; + Dali::TtsPlayer *arg1 = (Dali::TtsPlayer *) 0 ; + Dali::TtsPlayer::StateChangedSignalType *result = 0 ; + + arg1 = (Dali::TtsPlayer *)jarg1; + { + try { + result = (Dali::TtsPlayer::StateChangedSignalType *) &(arg1)->StateChangedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StateChangedSignalType_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__Empty((Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StateChangedSignalType_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StateChangedSignalType_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *) 0 ; + void (*arg2)(Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) = (void (*)(Dali::TtsPlayer::State const,Dali::TtsPlayer::State const)) 0 ; + + arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *)jarg1; + arg2 = (void (*)(Dali::TtsPlayer::State const,Dali::TtsPlayer::State const))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StateChangedSignalType_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *) 0 ; + void (*arg2)(Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) = (void (*)(Dali::TtsPlayer::State const,Dali::TtsPlayer::State const)) 0 ; + + arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *)jarg1; + arg2 = (void (*)(Dali::TtsPlayer::State const,Dali::TtsPlayer::State const))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StateChangedSignalType_Emit(void * jarg1, int jarg2, int jarg3) { + Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *) 0 ; + Dali::TtsPlayer::State arg2 ; + Dali::TtsPlayer::State arg3 ; + + arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *)jarg1; + arg2 = (Dali::TtsPlayer::State)jarg2; + arg3 = (Dali::TtsPlayer::State)jarg3; + { + try { + Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__Emit(arg1,arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StateChangedSignalType() { + void * jresult ; + Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *)new Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StateChangedSignalType(void * jarg1) { + Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/dali-adaptor/watch-wrap.cpp b/dali-csharp-binder/dali-adaptor/watch-wrap.cpp new file mode 100755 index 00000000..1f919319 --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/watch-wrap.cpp @@ -0,0 +1,790 @@ +/* + * Copyright (c) 2017 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// EXTERNAL INCLUDES +#include +#include + +// INTERNAL INCLUDES +#include + +/* Callback for returning strings to C# without leaking memory */ +typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + + +// keep argcs and argv so they're always available to DALi +int argWatchC = 1; +char **argWatchV = NULL; + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > const *self){ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *self,void (*func)(Dali::Application &,Dali::WatchTime const &)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *self,void (*func)(Dali::Application &,Dali::WatchTime const &)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *self,Dali::Application &arg1,Dali::WatchTime const &arg2){ + self->Emit( arg1, arg2 ); +} + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Application &,bool) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &,bool) > const *self){ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Application &,bool) > *self,void (*func)(Dali::Application &,bool)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &,bool) > *self,void (*func)(Dali::Application &,bool)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Application &,bool) > *self,Dali::Application &arg1,bool arg2){ + self->Emit( arg1, arg2 ); +} + +#ifdef __cplusplus +extern "C" { +#endif + +/*watch binding*/ + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchTime() { + void * jresult ; + Dali::WatchTime *result = 0 ; + + { + try { + result = (Dali::WatchTime *)new Dali::WatchTime(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WatchTime(void * jarg1) { + Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; + + arg1 = (Dali::WatchTime *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetHour(void * jarg1) { + int jresult ; + Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; + int result; + + arg1 = (Dali::WatchTime *)jarg1; + { + try { + result = (int)((Dali::WatchTime const *)arg1)->GetHour(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetHour24(void * jarg1) { + int jresult ; + Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; + int result; + + arg1 = (Dali::WatchTime *)jarg1; + { + try { + result = (int)((Dali::WatchTime const *)arg1)->GetHour24(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetMinute(void * jarg1) { + int jresult ; + Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; + int result; + + arg1 = (Dali::WatchTime *)jarg1; + { + try { + result = (int)((Dali::WatchTime const *)arg1)->GetMinute(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetSecond(void * jarg1) { + int jresult ; + Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; + int result; + + arg1 = (Dali::WatchTime *)jarg1; + { + try { + result = (int)((Dali::WatchTime const *)arg1)->GetSecond(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetMillisecond(void * jarg1) { + int jresult ; + Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; + int result; + + arg1 = (Dali::WatchTime *)jarg1; + { + try { + result = (int)((Dali::WatchTime const *)arg1)->GetMillisecond(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetYear(void * jarg1) { + int jresult ; + Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; + int result; + + arg1 = (Dali::WatchTime *)jarg1; + { + try { + result = (int)((Dali::WatchTime const *)arg1)->GetYear(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetMonth(void * jarg1) { + int jresult ; + Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; + int result; + + arg1 = (Dali::WatchTime *)jarg1; + { + try { + result = (int)((Dali::WatchTime const *)arg1)->GetMonth(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetDay(void * jarg1) { + int jresult ; + Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; + int result; + + arg1 = (Dali::WatchTime *)jarg1; + { + try { + result = (int)((Dali::WatchTime const *)arg1)->GetDay(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetDayOfWeek(void * jarg1) { + int jresult ; + Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; + int result; + + arg1 = (Dali::WatchTime *)jarg1; + { + try { + result = (int)((Dali::WatchTime const *)arg1)->GetDayOfWeek(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchTime_GetUtcTime(void * jarg1) { + void * jresult ; + Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; + tm result; + + arg1 = (Dali::WatchTime *)jarg1; + { + try { + result = ((Dali::WatchTime const *)arg1)->GetUtcTime(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new tm((const tm &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchTime_GetUtcTimeStamp(void * jarg1) { + void * jresult ; + Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; + time_t result; + + arg1 = (Dali::WatchTime *)jarg1; + { + try { + result = ((Dali::WatchTime const *)arg1)->GetUtcTimeStamp(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new time_t((const time_t &)result); + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_WatchTime_GetTimeZone(void * jarg1) { + char * jresult ; + Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; + char *result = 0 ; + + arg1 = (Dali::WatchTime *)jarg1; + { + try { + result = (char *)((Dali::WatchTime const *)arg1)->GetTimeZone(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WatchTime_GetDaylightSavingTimeStatus(void * jarg1) { + unsigned int jresult ; + Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; + bool result; + + arg1 = (Dali::WatchTime *)jarg1; + { + try { + result = (bool)((Dali::WatchTime const *)arg1)->GetDaylightSavingTimeStatus(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_New__SWIG_0() { + void * jresult ; + Dali::WatchApplication result; + + { + try { + result = Dali::WatchApplication::New(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::WatchApplication((const Dali::WatchApplication &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_New__SWIG_1(int jarg1, char * jarg2) { + void * jresult ; + int *arg1 = (int *) 0 ; + char ***arg2 ; + Dali::WatchApplication result; + { + int index = 0; + int length = 0; + char *retPtr; + char *nextPtr; + argWatchC = jarg1; + argWatchV = new char*[jarg1 + 1]; + + retPtr = strtok_r(jarg2, " ", &nextPtr); + if( retPtr ) + { + length = strlen(retPtr); + } + argWatchV[index] = new char[length + 1]; + if( retPtr ) + { + strncpy(argWatchV[index], retPtr, length); + } + argWatchV[index][length] = '\0'; + index++; + + while( index < jarg1 ) + { + length = 0; + retPtr = strtok_r(NULL, " ", &nextPtr); + if( retPtr ) + { + length = strlen(retPtr); + } + argWatchV[index] = new char[length + 1]; + if( retPtr ) + { + strncpy(argWatchV[index], retPtr, length); + } + argWatchV[index][length] = '\0'; + index++; + } + } + + argWatchV[jarg1] = NULL; + + arg1 = &argWatchC; + arg2 = &argWatchV; + { + try { + result = Dali::WatchApplication::New(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::WatchApplication((const Dali::WatchApplication &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_New__SWIG_2(int jarg1, char * jarg2, char * jarg3) { + void * jresult ; + int *arg1 = (int *) 0 ; + char ***arg2 ; + std::string *arg3 = 0 ; + Dali::WatchApplication result; + { + int index = 0; + int length = 0; + char *retPtr; + char *nextPtr; + argWatchC = jarg1; + argWatchV = new char*[jarg1 + 1]; + + retPtr = strtok_r(jarg2, " ", &nextPtr); + if( retPtr ) + { + length = strlen(retPtr); + } + argWatchV[index] = new char[length + 1]; + if( retPtr ) + { + strncpy(argWatchV[index], retPtr, length); + } + argWatchV[index][length] = '\0'; + index++; + + while( index < jarg1 ) + { + length = 0; + retPtr = strtok_r(NULL, " ", &nextPtr); + if( retPtr ) + { + length = strlen(retPtr); + } + argWatchV[index] = new char[length + 1]; + if( retPtr ) + { + strncpy(argWatchV[index], retPtr, length); + } + argWatchV[index][length] = '\0'; + index++; + } + } + + argWatchV[jarg1] = NULL; + + arg1 = &argWatchC; + arg2 = &argWatchV; + if (!jarg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg3_str(jarg3); + arg3 = &arg3_str; + { + try { + result = Dali::WatchApplication::New(arg1,arg2,(std::string const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::WatchApplication((const Dali::WatchApplication &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchApplication__SWIG_0() { + void * jresult ; + Dali::WatchApplication *result = 0 ; + + { + try { + result = (Dali::WatchApplication *)new Dali::WatchApplication(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchApplication__SWIG_1(void * jarg1) { + void * jresult ; + Dali::WatchApplication *arg1 = 0 ; + Dali::WatchApplication *result = 0 ; + + arg1 = (Dali::WatchApplication *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WatchApplication const & type is null", 0); + return 0; + } + { + try { + result = (Dali::WatchApplication *)new Dali::WatchApplication((Dali::WatchApplication const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::WatchApplication *arg1 = (Dali::WatchApplication *) 0 ; + Dali::WatchApplication *arg2 = 0 ; + Dali::WatchApplication *result = 0 ; + + arg1 = (Dali::WatchApplication *)jarg1; + arg2 = (Dali::WatchApplication *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WatchApplication const & type is null", 0); + return 0; + } + { + try { + result = (Dali::WatchApplication *) &(arg1)->operator =((Dali::WatchApplication const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WatchApplication(void * jarg1) { + Dali::WatchApplication *arg1 = (Dali::WatchApplication *) 0 ; + + arg1 = (Dali::WatchApplication *)jarg1; + { + try { + delete arg1; + if( argWatchV ) + { + //free string data + for (int i=0; iTimeTickSignal(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_AmbientTickSignal(void * jarg1) { + void * jresult ; + Dali::WatchApplication *arg1 = (Dali::WatchApplication *) 0 ; + Dali::WatchApplication::WatchTimeSignal *result = 0 ; + + arg1 = (Dali::WatchApplication *)jarg1; + { + try { + result = (Dali::WatchApplication::WatchTimeSignal *) &(arg1)->AmbientTickSignal(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_AmbientChangedSignal(void * jarg1) { + void * jresult ; + Dali::WatchApplication *arg1 = (Dali::WatchApplication *) 0 ; + Dali::WatchApplication::WatchBoolSignal *result = 0 ; + + arg1 = (Dali::WatchApplication *)jarg1; + { + try { + result = (Dali::WatchApplication::WatchBoolSignal *) &(arg1)->AmbientChangedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WatchTimeSignal_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WatchTimeSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchTimeSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ; + void (*arg2)(Dali::Application &,Dali::WatchTime const &) = (void (*)(Dali::Application &,Dali::WatchTime const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1; + arg2 = (void (*)(Dali::Application &,Dali::WatchTime const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchTimeSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ; + void (*arg2)(Dali::Application &,Dali::WatchTime const &) = (void (*)(Dali::Application &,Dali::WatchTime const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1; + arg2 = (void (*)(Dali::Application &,Dali::WatchTime const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchTimeSignal_Emit(void * jarg1, void * jarg2, void * jarg3) { + Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ; + Dali::Application *arg2 = 0 ; + Dali::WatchTime *arg3 = 0 ; + + arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1; + arg2 = (Dali::Application *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0); + return ; + } + arg3 = (Dali::WatchTime *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WatchTime const & type is null", 0); + return ; + } + { + try { + Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Emit(arg1,*arg2,(Dali::WatchTime const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchTimeSignal() { + void * jresult ; + Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)new Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) >(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WatchTimeSignal(void * jarg1) { + Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WatchBoolSignal_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Application &,bool) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WatchBoolSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,bool) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchBoolSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ; + void (*arg2)(Dali::Application &,bool) = (void (*)(Dali::Application &,bool)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1; + arg2 = (void (*)(Dali::Application &,bool))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchBoolSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ; + void (*arg2)(Dali::Application &,bool) = (void (*)(Dali::Application &,bool)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1; + arg2 = (void (*)(Dali::Application &,bool))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchBoolSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) { + Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ; + Dali::Application *arg2 = 0 ; + bool arg3 ; + + arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1; + arg2 = (Dali::Application *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0); + return ; + } + arg3 = jarg3 ? true : false; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Emit(arg1,*arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchBoolSignal() { + void * jresult ; + Dali::Signal< void (Dali::Application &,bool) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Application &,bool) > *)new Dali::Signal< void (Dali::Application &,bool) >(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WatchBoolSignal(void * jarg1) { + Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/dali-adaptor/window-data-wrap.cpp b/dali-csharp-binder/dali-adaptor/window-data-wrap.cpp new file mode 100644 index 00000000..6bcd3530 --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/window-data-wrap.cpp @@ -0,0 +1,202 @@ +/* + * Copyright (c) 2023 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. + * + */ + +#include + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_WindowData() +{ + void* nuiResult; + Dali::WindowData* result = 0; + + { + try + { + result = (Dali::WindowData*)new Dali::WindowData(); + } + CALL_CATCH_EXCEPTION(0); + } + + nuiResult = (void*)result; + return nuiResult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowData(void* nuiWindowData) +{ + Dali::WindowData* handle = (Dali::WindowData*)0; + + handle = (Dali::WindowData*)nuiWindowData; + { + try + { + delete handle; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowData_SetPositionSize(void* nuiWindowData, void* nuiPositionSize) +{ + Dali::WindowData* pWindowData; + Dali::Rect* rect = 0; + + pWindowData = (Dali::WindowData*)nuiWindowData; + if(!pWindowData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::WindowData", 0); + return; + } + + rect = (Dali::Rect*)nuiPositionSize; + if(!rect) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); + return; + } + { + try + { + pWindowData->SetPositionSize(*rect); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_WindowData_GetPositionSize(void* nuiWindowData) +{ + void* nuiResult; + Dali::WindowData* pWindowData; + Dali::Rect result; + + pWindowData = (Dali::WindowData*)nuiWindowData; + if(!pWindowData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::WindowData", 0); + return nullptr; + } + + { + try + { + result = pWindowData->GetPositionSize(); + } + CALL_CATCH_EXCEPTION(0); + } + + nuiResult = new Dali::Rect((const Dali::Rect&)result); + return nuiResult; +} + +// -- +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowData_SetWindowType(void* nuiWindowData, int nuiWindowType) +{ + Dali::WindowData* pWindowData; + Dali::WindowType windowType; + + pWindowData = (Dali::WindowData*)nuiWindowData; + if(!pWindowData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::WindowData", 0); + return; + } + + windowType = (Dali::WindowType)nuiWindowType; + { + try + { + pWindowData->SetWindowType(windowType); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WindowData_GetWindowType(void* nuiWindowData) +{ + int nuiResult; + Dali::WindowData* pWindowData; + Dali::WindowType result; + + pWindowData = (Dali::WindowData*)nuiWindowData; + if(!pWindowData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::WindowData", 0); + return 0; + } + + { + try + { + result = (Dali::WindowType)pWindowData->GetWindowType(); + } + CALL_CATCH_EXCEPTION(0); + } + + nuiResult = (int)result; + return nuiResult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowData_SetTransparency(void* nuiWindowData, bool nuiTransparency) +{ + Dali::WindowData* pWindowData; + + pWindowData = (Dali::WindowData*)nuiWindowData; + if(!pWindowData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::WindowData", 0); + return; + } + + { + try + { + pWindowData->SetTransparency(nuiTransparency); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WindowData_GetTransparency(void* nuiWindowData) +{ + Dali::WindowData* pWindowData; + bool result; + + pWindowData = (Dali::WindowData*)nuiWindowData; + if(!pWindowData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::WindowData", 0); + return 0; + } + + { + try + { + result = (bool)pWindowData->GetTransparency(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-adaptor/window-wrap.cpp b/dali-csharp-binder/dali-adaptor/window-wrap.cpp new file mode 100644 index 00000000..bf9227c3 --- /dev/null +++ b/dali-csharp-binder/dali-adaptor/window-wrap.cpp @@ -0,0 +1,3829 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include +#include +#include + +// INTERNAL INCLUDES +#include + +/* Callback for returning strings to C# without leaking memory */ +typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + + + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Window, bool) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Window, bool) > const *self){ +return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Window, bool) > *self,void (*func)(Dali::Window, bool)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Window, bool) > *self,void (*func)(Dali::Window, bool)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Window, bool) > *self,Dali::Window arg, bool focusIn){ + self->Emit( arg, focusIn ); +} + +/*ResizeSignal*/ +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Empty(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *self){ +return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Connect(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *self,void (*func)(Dali::Window, Dali::Window::WindowSize)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Disconnect(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *self,void (*func)(Dali::Window, Dali::Window::WindowSize)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Emit(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *self, Dali::Window arg, Dali::Window::WindowSize size){ + self->Emit( arg, size ); +} + +//Transition effect +SWIGINTERN bool Dali_Signal_Window_Transition_Effect_Event_Signal_Empty(Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Window_Transition_Effect_Event_Signal_GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > const *self){ +return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Window_Transition_Effect_Event_Signal_Connect(Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *self, void (*func)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Window_Transition_Effect_Event_Signal_Disconnect(Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *self,void (*func)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Window_Transition_Effect_Event_Signal_Emit(Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *self,Dali::Window arg, Dali::WindowEffectState state, Dali::WindowEffectType type){ + self->Emit( arg, state, type ); +} + +/* Moved signal */ +SWIGINTERN bool Dali_Signal_Window_Moved_Signal_Empty(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Window_Moved_Signal_GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *self){ +return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Window_Moved_Signal_Connect(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *self, void (*func)(Dali::Window, Dali::Window::WindowPosition)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Window_Moved_Signal_Disconnect(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *self,void (*func)(Dali::Window, Dali::Window::WindowPosition)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Window_Moved_Signal_Emit(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *self,Dali::Window window, Dali::Window::WindowPosition position){ + self->Emit( window, position ); +} + +//Orientation Changed +SWIGINTERN bool Dali_Signal_Window_Orientation_Changed_Signal_Empty(Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Window_Orientation_Changed_Signal_GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > const *self){ +return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Window_Orientation_Changed_Signal_Connect(Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *self, void (*func)(Dali::Window, Dali::WindowOrientation)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Window_Orientation_Changed_Signal_Disconnect(Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *self, void (*func)(Dali::Window, Dali::WindowOrientation)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Window_Orientation_Changed_Signal_Emit(Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *self, Dali::Window arg, Dali::WindowOrientation orientation){ + self->Emit( arg, orientation ); +} + +//input +SWIGINTERN bool Dali_Signal_Window_MouseInOutEvent_Signal_Empty(Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Window_MouseInOutEvent_Signal_GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > const *self){ +return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Window_MouseInOutEvent_Signal_Connect(Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *self, void (*func)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Window_MouseInOutEvent_Signal_Disconnect(Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *self, void (*func)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Window_MouseInOutEvent_Signal_Emit(Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *self, Dali::Window arg, Dali::DevelWindow::MouseInOutEvent const &mouseInOutEvent){ + self->Emit( arg, mouseInOutEvent ); +} + +/* Move Completed signal */ +SWIGINTERN bool Dali_Signal_Window_Move_Completed_Signal_Empty(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Window_Move_Completed_Signal_GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *self){ +return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Window_Move_Completed_Signal_Connect(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *self, void (*func)(Dali::Window, Dali::Window::WindowPosition)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Window_Move_Completed_Signal_Disconnect(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *self,void (*func)(Dali::Window, Dali::Window::WindowPosition)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Window_Move_Completed_Signal_Emit(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *self,Dali::Window window, Dali::Window::WindowPosition position){ + self->Emit( window, position ); +} + +/* Resize Completed signal */ +SWIGINTERN bool Dali_Signal_Window_Resize_Completed_Signal_Empty(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Window_Resize_Completed_Signal_GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *self){ +return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Window_Resize_Completed_Signal_Connect(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *self, void (*func)(Dali::Window, Dali::Window::WindowSize)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Window_Resize_Completed_Signal_Disconnect(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *self,void (*func)(Dali::Window, Dali::Window::WindowSize)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Window_Resize_Completed_Signal_Emit(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *self,Dali::Window window, Dali::Window::WindowSize size){ + self->Emit( window, size ); +} + + +#ifdef __cplusplus +extern "C" { +#endif + +/*Window binding*/ +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +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; + + argp1 = (Dali::PositionSize *)jarg1; + if (!argp1) + { + arg1 = Dali::PositionSize(0, 0, 0, 0); + } + else + { + arg1 = *argp1; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = jarg3 ? true : false; + { + try { + result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Window((const Dali::Window &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) { + void * jresult ; + Dali::PositionSize arg1 ; + std::string *arg2 = 0 ; + 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; + { + try { + result = Dali::Window::New(arg1,(std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Window((const Dali::Window &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +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); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Window((const Dali::Window &)result); + + 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 ; + std::string *arg3 = 0 ; + 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; + { + try { + result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Window((const Dali::Window &)result); + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() { + void * jresult ; + Dali::Window *result = 0 ; + + { + try { + result = (Dali::Window *)new Dali::Window(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) { + Dali::Window *arg1 = (Dali::Window *) 0 ; + + arg1 = (Dali::Window *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Window *arg1 = 0 ; + Dali::Window *result = 0 ; + + arg1 = (Dali::Window *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Window *arg1 = (Dali::Window *) 0 ; + Dali::Window *arg2 = 0 ; + Dali::Window *result = 0 ; + + arg1 = (Dali::Window *)jarg1; + arg2 = (Dali::Window *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) { + Dali::Window *arg1 = (Dali::Window *) 0 ; + std::string arg2 ; + std::string arg3 ; + + arg1 = (Dali::Window *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + (&arg2)->assign(jarg2); + if (!jarg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + (&arg3)->assign(jarg3); + { + try { + (arg1)->SetClass(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) { + Dali::Window *arg1 = (Dali::Window *) 0 ; + + arg1 = (Dali::Window *)jarg1; + { + try { + (arg1)->Raise(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) { + Dali::Window *arg1 = (Dali::Window *) 0 ; + + arg1 = (Dali::Window *)jarg1; + { + try { + (arg1)->Lower(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) { + Dali::Window *arg1 = (Dali::Window *) 0 ; + + arg1 = (Dali::Window *)jarg1; + { + try { + (arg1)->Activate(); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Maximize(void * winHandle, bool maximize) { + Dali::Window *window = (Dali::Window *) 0 ; + + window = (Dali::Window *)winHandle; + { + try { + Dali::DevelWindow::Maximize(*window, maximize); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_IsMaximized(void * winHandle) { + Dali::Window *window = (Dali::Window *) 0 ; + bool isMaximized = false; + + window = (Dali::Window *)winHandle; + { + try { + isMaximized = Dali::DevelWindow::IsMaximized(*window); + } CALL_CATCH_EXCEPTION(false); + } + return isMaximized; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Set_Maximum_Size(void * winHandle, void * size) { + Dali::Window *window = (Dali::Window *) 0 ; + Dali::Window::WindowSize *winSize; + Dali::Window::WindowSize maximumSize; + + window = (Dali::Window *)winHandle; + + winSize = (Dali::Window::WindowSize *)size; + if (!winSize) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowSize", 0); + return ; + } + maximumSize = *winSize; + + { + try { + Dali::DevelWindow::SetMaximumSize(*window, maximumSize); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Minimize(void * winHandle, bool minimize) { + Dali::Window *window = (Dali::Window *) 0 ; + + window = (Dali::Window *)winHandle; + { + try { + Dali::DevelWindow::Minimize(*window, minimize); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_IsMinimized(void * winHandle) { + Dali::Window *window = (Dali::Window *) 0 ; + bool isMinimized = false; + + window = (Dali::Window *)winHandle; + { + try { + isMinimized = Dali::DevelWindow::IsMinimized(*window); + } CALL_CATCH_EXCEPTION(false); + } + return isMinimized; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Set_Minimum_Size(void * winHandle, void * size) { + Dali::Window *window = (Dali::Window *) 0 ; + Dali::Window::WindowSize *winSize; + Dali::Window::WindowSize minimumSize; + + window = (Dali::Window *)winHandle; + + winSize = (Dali::Window::WindowSize *)size; + if (!winSize) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowSize", 0); + return ; + } + minimumSize = *winSize; + + window = (Dali::Window *)winHandle; + { + try { + Dali::DevelWindow::SetMimimumSize(*window, minimumSize); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) { + Dali::Window *arg1 = (Dali::Window *) 0 ; + Dali::WindowOrientation arg2 ; + + arg1 = (Dali::Window *)jarg1; + arg2 = (Dali::WindowOrientation)jarg2; + { + try { + (arg1)->AddAvailableOrientation(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) { + Dali::Window *arg1 = (Dali::Window *) 0 ; + Dali::WindowOrientation arg2 ; + + arg1 = (Dali::Window *)jarg1; + arg2 = (Dali::WindowOrientation)jarg2; + { + try { + (arg1)->RemoveAvailableOrientation(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) { + Dali::Window *arg1 = (Dali::Window *) 0 ; + Dali::WindowOrientation arg2 ; + + arg1 = (Dali::Window *)jarg1; + arg2 = (Dali::WindowOrientation)jarg2; + { + try { + (arg1)->SetPreferredOrientation(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) { + int jresult ; + Dali::Window *arg1 = (Dali::Window *) 0 ; + Dali::WindowOrientation result; + + arg1 = (Dali::Window *)jarg1; + { + try { + result = (Dali::WindowOrientation)(arg1)->GetPreferredOrientation(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetCurrentOrientation(void * jarg1) { + int jresult ; + Dali::WindowOrientation result; + Dali::Window* window = (Dali::Window*)jarg1; + if (!window) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + { + try { + result = Dali::DevelWindow::GetCurrentOrientation(*window); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetAvailableOrientations(void * jarg1, void* jarg2, int jarg3) { + Dali::Window* window = (Dali::Window*)jarg1; + if(!window) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return; + } + Dali::Property::Array *arg2 = (static_cast(jarg2)); + unsigned int count = static_cast(jarg3); + + Dali::Vector< Dali::WindowOrientation> orientations; + orientations.Resize( count ); + for(Dali::Property::Array::SizeType i = 0; i < count; ++i) + { + int angle = arg2->GetElementAt(i).Get(); + orientations[i] = static_cast< Dali::WindowOrientation >(angle); + } + { + try { + Dali::DevelWindow::SetAvailableOrientations(*window, orientations); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) { + void * jresult ; + Dali::Window *arg1 = (Dali::Window *) 0 ; + Dali::Any result; + + arg1 = (Dali::Window *)jarg1; + { + try { + result = ((Dali::Window const *)arg1)->GetNativeHandle(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Any((const Dali::Any &)result); + return jresult; +} + +/*window-devel binding*/ + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) { + void * jresult ; + Dali::Window arg1 ; + Dali::Window *argp1 ; + Dali::Window::FocusChangeSignalType *result = 0 ; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + arg1 = *argp1; + { + try { + result = (Dali::Window::FocusChangeSignalType*)&arg1.FocusChangeSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) { + Dali::Window arg1 ; + bool arg2 ; + Dali::Window *argp1 ; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + arg1 = *argp1; + arg2 = jarg2 ? true : false; + { + try { + arg1.SetAcceptFocus(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) { + unsigned int jresult ; + Dali::Window arg1 ; + Dali::Window *argp1 ; + bool result; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + arg1 = *argp1; + { + try { + result = (bool)arg1.IsFocusAcceptable(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) { + Dali::Window arg1 ; + Dali::Window *argp1 ; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + arg1 = *argp1; + { + try { + arg1.Show(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) { + Dali::Window arg1 ; + Dali::Window *argp1 ; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + arg1 = *argp1; + { + try { + arg1.Hide(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) { + unsigned int jresult ; + Dali::Window arg1 ; + Dali::Window *argp1 ; + bool result; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + arg1 = *argp1; + { + try { + result = (bool)arg1.IsVisible(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHintCount(void * jarg1) { + unsigned int jresult ; + Dali::Window arg1 ; + Dali::Window *argp1 ; + unsigned int result; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + arg1 = *argp1; + { + try { + result = (unsigned int)arg1.GetSupportedAuxiliaryHintCount(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHint(void * jarg1, unsigned int jarg2) { + char * jresult ; + Dali::Window arg1 ; + unsigned int arg2 ; + Dali::Window *argp1 ; + std::string result; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + arg1 = *argp1; + arg2 = (unsigned int)jarg2; + { + try { + result = arg1.GetSupportedAuxiliaryHint(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback((&result)->c_str()); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AddAuxiliaryHint(void * jarg1, char * jarg2, char * jarg3) { + unsigned int jresult ; + Dali::Window arg1 ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + Dali::Window *argp1 ; + unsigned int result; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 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; + { + try { + result = (unsigned int)arg1.AddAuxiliaryHint((std::string const &)*arg2,(std::string const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RemoveAuxiliaryHint(void * jarg1, unsigned int jarg2) { + unsigned int jresult ; + Dali::Window arg1 ; + unsigned int arg2 ; + Dali::Window *argp1 ; + bool result; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + arg1 = *argp1; + arg2 = (unsigned int)jarg2; + { + try { + result = (bool)arg1.RemoveAuxiliaryHint(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetAuxiliaryHintValue(void * jarg1, unsigned int jarg2, char * jarg3) { + unsigned int jresult ; + Dali::Window arg1 ; + unsigned int arg2 ; + std::string *arg3 = 0 ; + Dali::Window *argp1 ; + bool result; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + arg1 = *argp1; + arg2 = (unsigned int)jarg2; + if (!jarg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg3_str(jarg3); + arg3 = &arg3_str; + { + try { + result = (bool)arg1.SetAuxiliaryHintValue(arg2,(std::string const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintValue(void * jarg1, unsigned int jarg2) { + char * jresult ; + Dali::Window arg1 ; + unsigned int arg2 ; + Dali::Window *argp1 ; + std::string result; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + arg1 = *argp1; + arg2 = (unsigned int)jarg2; + { + try { + result = arg1.GetAuxiliaryHintValue(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback((&result)->c_str()); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintId(void * jarg1, char * jarg2) { + unsigned int jresult ; + Dali::Window arg1 ; + std::string *arg2 = 0 ; + Dali::Window *argp1 ; + unsigned int result; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + arg1 = *argp1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + result = (unsigned int)arg1.GetAuxiliaryHintId((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetInputRegion(void * jarg1, void * jarg2) { + Dali::Window arg1 ; + Dali::Rect< int > *arg2 = 0 ; + Dali::Window *argp1 ; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + arg1 = *argp1; + arg2 = (Dali::Rect< int > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); + return ; + } + { + try { + arg1.SetInputRegion((Dali::Rect< int > const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetType(void * jarg1, int jarg2) { + Dali::Window arg1 ; + Dali::WindowType arg2 ; + Dali::Window *argp1 ; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + arg1 = *argp1; + arg2 = (Dali::WindowType)jarg2; + { + try { + arg1.SetType(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetType(void * jarg1) { + int jresult ; + Dali::Window arg1 ; + Dali::Window *argp1 ; + Dali::WindowType result; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + arg1 = *argp1; + { + try { + result = (Dali::WindowType)arg1.GetType(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetNotificationLevel(void * jarg1, int jarg2) { + unsigned int jresult ; + Dali::Window arg1 ; + Dali::WindowNotificationLevel arg2 ; + Dali::Window *argp1 ; + int result; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + arg1 = *argp1; + arg2 = (Dali::WindowNotificationLevel)jarg2; + { + try { + result = (int)arg1.SetNotificationLevel(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetNotificationLevel(void * jarg1) { + int jresult ; + Dali::Window arg1 ; + Dali::Window *argp1 ; + Dali::WindowNotificationLevel result; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + arg1 = *argp1; + { + try { + result = (Dali::WindowNotificationLevel)arg1.GetNotificationLevel(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetOpaqueState(void * jarg1, unsigned int jarg2) { + Dali::Window arg1 ; + bool arg2 ; + Dali::Window *argp1 ; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + arg1 = *argp1; + arg2 = jarg2 ? true : false; + { + try { + arg1.SetOpaqueState(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsOpaqueState(void * jarg1) { + unsigned int jresult ; + Dali::Window arg1 ; + Dali::Window *argp1 ; + bool result; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + arg1 = *argp1; + { + try { + result = (bool)arg1.IsOpaqueState(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetScreenOffMode(void * jarg1, int jarg2) { + unsigned int jresult ; + Dali::Window arg1 ; + Dali::WindowScreenOffMode arg2 ; + Dali::Window *argp1 ; + int result; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + arg1 = *argp1; + arg2 = (Dali::WindowScreenOffMode)jarg2; + { + try { + result = (int)arg1.SetScreenOffMode(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetScreenOffMode(void * jarg1) { + int jresult ; + Dali::Window arg1 ; + Dali::Window *argp1 ; + Dali::WindowScreenOffMode result; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + arg1 = *argp1; + { + try { + result = (Dali::WindowScreenOffMode)arg1.GetScreenOffMode(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetBrightness(void * jarg1, int jarg2) { + unsigned int jresult ; + Dali::Window arg1 ; + int arg2 ; + Dali::Window *argp1 ; + int result; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + arg1 = *argp1; + arg2 = (int)jarg2; + { + try { + result = (int)arg1.SetBrightness(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetBrightness(void * jarg1) { + int jresult ; + Dali::Window arg1 ; + Dali::Window *argp1 ; + int result; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + arg1 = *argp1; + { + try { + result = (int)arg1.GetBrightness(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void (Dali::Window, bool) > *arg1 = (Dali::Signal< void (Dali::Window, bool) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Window, bool) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Window, bool) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Window, bool) > *arg1 = (Dali::Signal< void (Dali::Window, bool) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Window, bool) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Window, bool) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Window, bool) > *arg1 = (Dali::Signal< void (Dali::Window, bool) > *) 0 ; + void (*arg2)(Dali::Window, bool) = (void (*)(Dali::Window, bool)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Window, bool) > *)jarg1; + arg2 = (void (*)(Dali::Window, bool))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Window, bool) > *arg1 = (Dali::Signal< void (Dali::Window, bool) > *) 0 ; + void (*arg2)(Dali::Window, bool) = (void (*)(Dali::Window, bool)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Window, bool) > *)jarg1; + arg2 = (void (*)(Dali::Window, bool))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, void* jarg2, unsigned int jarg3) { + Dali::Signal< void (Dali::Window, bool) > *arg1 = (Dali::Signal< void (Dali::Window, bool) > *)jarg1; + Dali::Window* arg2 = (Dali::Window*)jarg2; + bool arg3 = jarg3 ? true : false;; + + if (arg1 == nullptr || arg2 == nullptr) { + DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr"); + return; + } + + { + try { + Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,*arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() { + void * jresult ; + Dali::Signal< void (Dali::Window, bool) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Window, bool) > *)new Dali::Signal< void (Dali::Window, bool) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) { + Dali::Signal< void (Dali::Window, bool) > *arg1 = (Dali::Signal< void (Dali::Window, bool) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Window, bool) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_ResizeSignal(void * jarg1) { + void * jresult ; + Dali::Window arg1 ; + Dali::Window *argp1 ; + Dali::Window::ResizeSignalType *result = 0 ; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + arg1 = *argp1; + { + try { + result = (Dali::Window::ResizeSignalType *) &arg1.ResizeSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +/*ResizedSignal binding*/ +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResizeSignal_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Empty((Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResizeSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResizeSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; + void (*arg2)(Dali::Window, Dali::Window::WindowSize) = (void (*)(Dali::Window, Dali::Window::WindowSize)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)jarg1; + arg2 = (void (*)(Dali::Window, Dali::Window::WindowSize))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResizeSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; + void (*arg2)(Dali::Window, Dali::Window::WindowSize) = (void (*)(Dali::Window, Dali::Window::WindowSize)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)jarg1; + arg2 = (void (*)(Dali::Window, Dali::Window::WindowSize))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResizeSignal_Emit(void * jarg1, void* jarg2, void * jarg3) { + Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; + Dali::Window* arg2 = (Dali::Window*)jarg2; + Dali::Window::WindowSize arg3 ; + Dali::Window::WindowSize *argp3 ; + + arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)jarg1; + if (arg1 == nullptr || arg2 == nullptr) { + DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr"); + return; + } + + argp3 = (Dali::Window::WindowSize *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowSize", 0); + return ; + } + arg3 = *argp3; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Emit(arg1,*arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResizeSignal() { + void * jresult ; + Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)new Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResizeSignal(void * jarg1) { + Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetSize(void * jarg1, void * jarg2) { + Dali::Window arg1 ; + Dali::Window::WindowSize arg2 ; + Dali::Window *argp1 ; + Dali::Window::WindowSize *argp2 ; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + arg1 = *argp1; + argp2 = (Dali::Window::WindowSize *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowSize", 0); + return ; + } + arg2 = *argp2; + { + try { + arg1.SetSize(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetSize(void * jarg1) { + void * jresult ; + Dali::Window arg1 ; + Dali::Window *argp1 ; + Dali::Window::WindowSize result; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + arg1 = *argp1; + { + try { + result = arg1.GetSize(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Window::WindowSize((const Dali::Window::WindowSize &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPosition(void * handle, void * position) { + Dali::Window *pWindow; + Dali::Window window; + Dali::Window::WindowPosition *pPosition; + Dali::Window::WindowPosition windowPosition; + + pWindow = (Dali::Window *)handle; + if (!pWindow) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + window = *pWindow; + + pPosition = (Dali::Window::WindowPosition *)position; + if (!pPosition) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::WindowPosition", 0); + return ; + } + windowPosition = *pPosition; + + { + try { + window.SetPosition(windowPosition); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetPosition(void * handle) { + Dali::Window *pWindow ; + Dali::Window window ; + Dali::Window::WindowPosition windowPosition; + Dali::Window::WindowPosition result; + void * jresult ; + + pWindow = (Dali::Window *)handle; + if (!pWindow) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + window = *pWindow; + { + try { + windowPosition = window.GetPosition(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Window::WindowPosition((const Dali::Window::WindowPosition &)windowPosition); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPositionSize(void* jarg1, void* jarg2) +{ + Dali::Window* window = (Dali::Window*)jarg1; + if (!window) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + + Dali::Rect* positionSize = (Dali::Rect*)jarg2; + if (!positionSize) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); + return ; + } + { + try { + Dali::DevelWindow::SetPositionSize(*window, *positionSize); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetLayout(void* handle, unsigned int numCols, unsigned int numRows, unsigned int column, unsigned int row, unsigned int colSpan, unsigned int rowSpan) +{ + Dali::Window *pWindow; + Dali::Window window; + + pWindow = (Dali::Window *)handle; + if (!pWindow) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + window = *pWindow; + + { + try { + window.SetLayout(numCols, numRows, column, row, colSpan, rowSpan); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetTransparency(void * jarg1, unsigned int jarg2) { + Dali::Window arg1 ; + bool arg2 ; + Dali::Window *argp1 ; + + argp1 = (Dali::Window *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + arg1 = *argp1; + arg2 = jarg2 ? true : false; + { + try { + arg1.SetTransparency(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_FeedKey_Default_Window(void * event) { + Dali::KeyEvent *keyEvent = 0 ; + + keyEvent = (Dali::KeyEvent *)event; + if (!keyEvent) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent & type is null", 0); + return ; + } + { + try { + Dali::Adaptor::Get().FeedKeyEvent(*keyEvent); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_FeedKey(void * window, void * event) { + Dali::Window* win = (Dali::Window*)window; + if (!win) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + + Dali::KeyEvent *keyEvent = 0 ; + keyEvent = (Dali::KeyEvent *)event; + if (!keyEvent) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent & type is null", 0); + return ; + } + { + try { + Dali::DevelWindow::FeedKeyEvent(*win, *keyEvent); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_FeedTouch(void * window, void * event, int timeStamp) { + Dali::Window* win = (Dali::Window*)window; + if (!win) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + + Dali::TouchPoint *touchPoint = 0 ; + touchPoint = (Dali::TouchPoint *)event; + if (!touchPoint) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint & type is null", 0); + return ; + } + { + try { + Dali::DevelWindow::FeedTouchPoint(*win, *touchPoint, timeStamp); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_FeedWheel(void * window, void * event) { + Dali::Window* win = (Dali::Window*)window; + if (!win) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + + Dali::WheelEvent *wheelEvent = 0 ; + wheelEvent = (Dali::WheelEvent *)event; + if (!wheelEvent) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent & type is null", 0); + return ; + } + { + try { + Dali::DevelWindow::FeedWheelEvent(*win, *wheelEvent); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_FeedHover(void * window, void * touchPoint) { + Dali::Window* win = (Dali::Window*)window; + if (!win) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + + Dali::TouchPoint *aTouchPoint = 0 ; + aTouchPoint = (Dali::TouchPoint *)touchPoint; + if (!aTouchPoint) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint & type is null", 0); + return ; + } + { + try { + Dali::DevelWindow::FeedHoverEvent(*win, *aTouchPoint); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_RenderOnce(void * /* jarg1 */) { + try { + Dali::Adaptor::Get().RenderOnce(); + } CALL_CATCH_EXCEPTION(); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Add(void * jarg1, void * jarg2) { + Dali::Window *arg1 = (Dali::Window *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Window *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->Add(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Remove(void * jarg1, void * jarg2) { + Dali::Window *arg1 = (Dali::Window *) 0 ; + Dali::Actor *arg2 = 0 ; + + arg1 = (Dali::Window *)jarg1; + arg2 = (Dali::Actor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); + return ; + } + { + try { + (arg1)->Remove(*arg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetBackgroundColor(void * jarg1, void * jarg2) { + Dali::Window *arg1 = (Dali::Window *) 0 ; + Dali::Vector4 arg2 ; + Dali::Vector4 *argp2 ; + + arg1 = (Dali::Window *)jarg1; + argp2 = (Dali::Vector4 *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetBackgroundColor(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetBackgroundColor(void * jarg1) { + void * jresult ; + Dali::Window *arg1 = (Dali::Window *) 0 ; + Dali::Vector4 result; + + arg1 = (Dali::Window *)jarg1; + { + try { + result = ((Dali::Window const *)arg1)->GetBackgroundColor(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetRootLayer(void * csWindow) { + void * jresult ; + Dali::Window *window = (Dali::Window *) 0 ; + Dali::Layer result; + + window = (Dali::Window *)csWindow; + { + try { + result = ((Dali::Window const *)window)->GetRootLayer(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Layer((const Dali::Layer &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetOverlayLayer(void * csWindow) { + void * jresult ; + Dali::Window *window = (Dali::Window *) 0 ; + Dali::Layer result; + + window = (Dali::Window *)csWindow; + { + try { + result = ((Dali::Window *)window)->GetOverlayLayer(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Layer((const Dali::Layer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_KeyEventSignal(void * jarg1) { + void * jresult ; + Dali::Window *arg1 = (Dali::Window *) 0 ; + Dali::Window::KeyEventSignalType *result = 0 ; + + arg1 = (Dali::Window *)jarg1; + { + try { + result = (Dali::Window::KeyEventSignalType *) &(arg1->KeyEventSignal()); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_InterceptKeyEventSignal(void * winHandle) { + void * jresult ; + Dali::Window *window = (Dali::Window *) 0 ; + Dali::DevelWindow::InterceptKeyEventSignalType *result = 0 ; + + window = (Dali::Window *)winHandle; + if (!window) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + { + try { + result = (Dali::DevelWindow::InterceptKeyEventSignalType *) &(Dali::DevelWindow::InterceptKeyEventSignal(*window)); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_TouchSignal(void * jarg1) { + void * jresult ; + Dali::Window *arg1 = (Dali::Window *) 0 ; + Dali::Window::TouchEventSignalType *result = 0 ; + + arg1 = (Dali::Window *)jarg1; + { + try { + result = (Dali::Window::TouchEventSignalType *) &(arg1->TouchedSignal()); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetParent(void* child, void* parent) +{ + Dali::Window* childWindow = (Dali::Window*)child; + if (!childWindow) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + + Dali::Window* parentWindow = (Dali::Window*)parent; + if (!parentWindow) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + { + try { + Dali::DevelWindow::SetParent(*childWindow, *parentWindow); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetParent_With_Stack(void* child, void* parent, bool belowParent) +{ + Dali::Window* childWindow = (Dali::Window*)child; + if (!childWindow) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + + Dali::Window* parentWindow = (Dali::Window*)parent; + if (!parentWindow) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + { + try { + Dali::DevelWindow::SetParent(*childWindow, *parentWindow, belowParent); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Unparent(void* jarg1) +{ + Dali::Window* window = (Dali::Window*)jarg1; + if (!window) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + { + try { + Dali::DevelWindow::Unparent(*window); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetParent(void* jarg1) +{ + void * jresult ; + Dali::Window* window = (Dali::Window*)jarg1; + Dali::Window result; + if (!window) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + { + try { + result = Dali::DevelWindow::GetParent(*window); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Window((const Dali::Window &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetWindow(void * jarg1) { + void * jresult ; + Dali::Window result; + + { + try { + result = Dali::DevelWindow::Get(*(Dali::Actor*)jarg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Window((const Dali::Window &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_EventSignal(void * jarg1) { + void * jresult ; + Dali::Window *arg1 = (Dali::Window *) 0 ; + Dali::DevelWindow::TransitionEffectEventSignalType *result = 0 ; + + arg1 = (Dali::Window *)jarg1; + { + try { + result = (Dali::DevelWindow::TransitionEffectEventSignalType *) &(Dali::DevelWindow::TransitionEffectEventSignal(*arg1)); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Window_Transition_Effect_Event_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)jarg1; + { + try { + result = Dali_Signal_Window_Transition_Effect_Event_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *) 0 ; + void (*arg2)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) = (void (*)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)jarg1; + arg2 = (void (*)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType))jarg2; + { + try { + //DALI_LOG_ERROR("CSharp_Dali_Window_Transition_Effect_Event_Signal_Connect(arg1=0x%x, arg2=0x%x) \n", arg1, arg2); + Dali_Signal_Window_Transition_Effect_Event_Signal_Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *) 0 ; + void (*arg2)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) = (void (*)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)jarg1; + arg2 = (void (*)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType))jarg2; + { + try { + Dali_Signal_Window_Transition_Effect_Event_Signal_Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Emit(void * jarg1, void * jarg2, int jarg3, int jarg4) { + Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *) 0 ; + Dali::Window arg2 ; + Dali::Window *argp2 ; + + arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)jarg1; + argp2 = (Dali::Window *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + arg2 = *argp2; + { + try { + Dali_Signal_Window_Transition_Effect_Event_Signal_Emit(arg1,arg2, (Dali::WindowEffectState)jarg3, (Dali::WindowEffectType)jarg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_new() { + void * jresult ; + Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)new Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_delete(void * jarg1) { + Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +//////////////////////////////////////////////////////////////////// +/// Auxiliary Message event + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Auxiliary_Message_Signal(void * jarg1) { + void * jresult ; + Dali::Window *window = (Dali::Window *) 0 ; + Dali::DevelWindow::AuxiliaryMessageSignalType *result = 0 ; + + window = (Dali::Window *)jarg1; + { + try { + result = (Dali::DevelWindow::AuxiliaryMessageSignalType *) &(Dali::DevelWindow::AuxiliaryMessageSignal(*window)); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_Auxiliary_Message_Signal_Empty(void * jarg1) { + bool result; + Dali::DevelWindow::AuxiliaryMessageSignalType* arg1 = (Dali::DevelWindow::AuxiliaryMessageSignalType*) jarg1; + + if (arg1 == nullptr) { + DALI_LOG_ERROR("[ERR] arg1 == nullptr"); + return false; + } + + { + try { + result = arg1->Empty(); + } + CALL_CATCH_EXCEPTION(false); + } + return result; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Window_Auxiliary_Message_Signal_GetConnectionCount(void * jarg1) { + unsigned int result; + Dali::DevelWindow::AuxiliaryMessageSignalType* arg1 = (Dali::DevelWindow::AuxiliaryMessageSignalType *) jarg1; + + if (arg1 == nullptr) { + DALI_LOG_ERROR("[ERR] arg1 == nullptr"); + return 0; + } + + { + try { + result = arg1->GetConnectionCount(); + } + CALL_CATCH_EXCEPTION(0); + } + return result; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Auxiliary_Message_Signal_Connect(void * jarg1, void * jarg2) { + Dali::DevelWindow::AuxiliaryMessageSignalType* arg1 = (Dali::DevelWindow::AuxiliaryMessageSignalType *)jarg1; + void (*arg2)(const std::string&, const std::string&, const Dali::Property::Array&) = ( void (*)(const std::string&, const std::string&, const Dali::Property::Array&) )jarg2; + + if (arg1 == nullptr) { + DALI_LOG_ERROR("[ERR] arg1 == nullptr"); + return ; + } + + { + try { + arg1->Connect(arg2); + } + CALL_CATCH_EXCEPTION(); + } + return ; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Auxiliary_Message_Signal_Disconnect(void * jarg1, void * jarg2) { + Dali::DevelWindow::AuxiliaryMessageSignalType* arg1 = (Dali::DevelWindow::AuxiliaryMessageSignalType *)jarg1; + void (*arg2)(const std::string&, const std::string&, const Dali::Property::Array&) = ( void (*)(const std::string&, const std::string&, const Dali::Property::Array&) )jarg2; + + if (arg1 == nullptr) { + DALI_LOG_ERROR("[ERR] arg1 == nullptr"); + return; + } + + { + try { + arg1->Disconnect(arg2); + } + CALL_CATCH_EXCEPTION(); + } + return; +} + +///////////////// +// Keyboard Repeat Settings Changed +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_ChangedSignal(void * jarg1) { + void * jresult ; + Dali::Window *arg1 = (Dali::Window *) 0 ; + Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *result = 0 ; + + arg1 = (Dali::Window *)jarg1; + { + try { + result = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *) &(Dali::DevelWindow::KeyboardRepeatSettingsChangedSignal(*arg1)); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_Empty(void * jarg1) { + unsigned int jresult ; + Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType*)jarg1; + if (arg1 == nullptr) { + DALI_LOG_ERROR("[ERR] arg1 == nullptr"); + return false; + } + + bool result; + { + try { + result = (bool)((Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType const *)arg1)->Empty(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *)jarg1; + if (arg1 == nullptr) { + DALI_LOG_ERROR("[ERR] arg1 == nullptr"); + return false; + } + + std::size_t result; + { + try { + result = ((Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType const *)arg1)->GetConnectionCount(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_Connect(void * jarg1, void * jarg2) { + Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *)jarg1; + void (*arg2)() = (void (*)())jarg2; + + if (arg1 == nullptr) { + DALI_LOG_ERROR("[ERR] arg1 == nullptr"); + return; + } + + { + try { + (arg1)->Connect(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_Disconnect(void * jarg1, void * jarg2) { + Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *)jarg1; + void (*arg2)() = (void (*)())jarg2; + + if (arg1 == nullptr) { + DALI_LOG_ERROR("[ERR] arg1 == nullptr"); + return; + } + + { + try { + (arg1)->Disconnect(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_Emit(void * jarg1) { + Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *)jarg1; + + if (arg1 == nullptr) { + DALI_LOG_ERROR("[ERR] arg1 == nullptr"); + return; + } + + { + try { + (arg1)->Emit(); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_new() { + void * jresult ; + Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *result = 0; + + { + try { + result = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *)new Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_delete(void * jarg1) { + Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType*) 0; + + arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal(void* jarg1) { + Dali::Window* arg1 = (Dali::Window*) jarg1; + Dali::DevelWindow::VisibilityChangedSignalType* result = 0; + + { + try { + result = (Dali::DevelWindow::VisibilityChangedSignalType*) &( Dali::DevelWindow::VisibilityChangedSignal(*arg1) ); + } + CALL_CATCH_EXCEPTION(0); + } + return (void*)result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_Empty(void* jarg1) { + bool result; + Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType*) jarg1; + + if (arg1 == nullptr) { + DALI_LOG_ERROR("[ERR] arg1 == nullptr"); + return false; + } + + { + try { + result = arg1->Empty(); + } + CALL_CATCH_EXCEPTION(false); + } + return result; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_GetConnectionCount(void* jarg1) { + unsigned int result; + Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType *) jarg1; + + if (arg1 == nullptr) { + DALI_LOG_ERROR("[ERR] arg1 == nullptr"); + return 0; + } + + { + try { + result = arg1->GetConnectionCount(); + } + CALL_CATCH_EXCEPTION(0); + } + return result; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_Connect(void* jarg1, void* jarg2) { + Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType *)jarg1; + void (*arg2)(Dali::Window, bool) = ( void (*)(Dali::Window, bool) )jarg2; + + if (arg1 == nullptr) { + DALI_LOG_ERROR("[ERR] arg1 == nullptr"); + return ; + } + + { + try { + arg1->Connect(arg2); + } + CALL_CATCH_EXCEPTION(); + } + return ; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_Disconnect(void* jarg1, void* jarg2) { + Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType*)jarg1; + void (*arg2)(Dali::Window, bool) = (void (*)(Dali::Window, bool))jarg2; + + if (arg1 == nullptr) { + DALI_LOG_ERROR("[ERR] arg1 == nullptr"); + return; + } + + { + try { + arg1->Disconnect(arg2); + } + CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_Emit(void* jarg1, void* jarg2, bool jarg3) { + Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType*)jarg1; + Dali::Window* arg2 = (Dali::Window*)jarg2; + bool arg3 = jarg3; + + if (arg1 == nullptr || arg2 == nullptr) { + DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr"); + return; + } + + { + try { + arg1->Emit(*arg2, arg3); + } + CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_delete(void* jarg1) { + Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType*)jarg1; + + { + try { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT int32_t SWIGSTDCALL CSharp_Dali_Window_GetNativeId( void* jarg1 ) +{ + Dali::Window* window = (Dali::Window*)jarg1; + int32_t ret = -1; + if( !window ) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ret; + } + + { + try { + ret = Dali::DevelWindow::GetNativeId( *window ); + } + CALL_CATCH_EXCEPTION(ret); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddFrameRenderedCallback( void* nuiWindow, void* nuiCallback, int nuiFrameId ) +{ + Dali::Window* window = (Dali::Window*)nuiWindow; + void (*callback)(int32_t) = (void (*)(int32_t))nuiCallback; + + if( !window || !callback ) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null", 0); + return; + } + + try + { + Dali::DevelWindow::AddFrameRenderedCallback( *window, std::unique_ptr< Dali::CallbackBase >( Dali::MakeCallback( callback ) ), nuiFrameId ); + } + CALL_CATCH_EXCEPTION(); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddFramePresentedCallback( void* nuiWindow, void* nuiCallback, int nuiFrameId ) +{ + Dali::Window* window = (Dali::Window*)nuiWindow; + void (*callback)(int32_t) = (void (*)(int32_t))nuiCallback; + + if( !window || !callback ) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null", 0); + return; + } + + try + { + Dali::DevelWindow::AddFramePresentedCallback( *window, std::unique_ptr< Dali::CallbackBase >( Dali::MakeCallback( callback ) ), nuiFrameId ); + } + CALL_CATCH_EXCEPTION(); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPositionSizeWithOrientation(void* jarg1, void* jarg2, int jarg3) +{ + Dali::Window* window = (Dali::Window*)jarg1; + if (!window) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + + Dali::Rect* positionSize = (Dali::Rect*)jarg2; + if (!positionSize) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); + return ; + } + + Dali::WindowOrientation orientation = (Dali::WindowOrientation)jarg3; + { + try { + Dali::DevelWindow::SetPositionSizeWithOrientation(*window, *positionSize, orientation); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RequestMoveToServer(void* jarg1) +{ + Dali::Window* window = (Dali::Window*)jarg1; + if (!window) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + + { + try { + Dali::DevelWindow::RequestMoveToServer(*window); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RequestResizeToServer(void* jarg1, int jarg2) +{ + Dali::Window* window = (Dali::Window*)jarg1; + if (!window) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + + Dali::WindowResizeDirection direction = (Dali::WindowResizeDirection)jarg2; + + { + try { + Dali::DevelWindow::RequestResizeToServer(*window, direction); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_EnableFloatingMode(void* jarg1, bool jarg2) +{ + Dali::Window* window = (Dali::Window*)jarg1; + if (!window) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return; + } + + bool enable = jarg2; + { + try { + Dali::DevelWindow::EnableFloatingMode(*window, enable); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_IsFloatingModeEnabled(void* winHandle) +{ + Dali::Window* window = (Dali::Window*)winHandle; + bool result = false; + if (!window) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return false; + } + + { + try { + result = Dali::DevelWindow::IsFloatingModeEnabled(*window); + } CALL_CATCH_EXCEPTION(0); + } + return result; + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_IncludeInputRegion(void* winHandle, void* region) +{ + Dali::Window* window = (Dali::Window*)winHandle; + Dali::Rect *addedRegion = (Dali::Rect *)region; + if (!window) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return; + } + { + try { + Dali::DevelWindow::IncludeInputRegion(*window, *addedRegion); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ExcludeInputRegion(void* winHandle, void* region) +{ + Dali::Window* window = (Dali::Window*)winHandle; + Dali::Rect *subtractedRegion = (Dali::Rect *)region; + if (!window) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return; + } + { + try { + Dali::DevelWindow::ExcludeInputRegion(*window, *subtractedRegion); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_KeepRendering(void* winHandle, float durationSeconds) +{ + Dali::Window* window = static_cast(winHandle); + if(!window) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return; + } + { + try + { + window->KeepRendering(durationSeconds); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPartialUpdateEnabled(void* winHandle, bool enabled) +{ + Dali::Window* window = static_cast(winHandle); + if(!window) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return; + } + { + try + { + window->SetPartialUpdateEnabled(enabled); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_IsPartialUpdateEnabled(void* winHandle) +{ + Dali::Window* window = static_cast(winHandle); + bool enabled = false; + if(!window) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return false; + } + { + try + { + enabled = window->IsPartialUpdateEnabled(); + } + CALL_CATCH_EXCEPTION(false); + } + return enabled; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal(void* winHandle) { + Dali::Window* window = (Dali::Window*) winHandle; + Dali::DevelWindow::AccessibilityHighlightSignalType* result = 0; + + { + try { + result = (Dali::DevelWindow::AccessibilityHighlightSignalType*) &( Dali::DevelWindow::AccessibilityHighlightSignal(*window) ); + } + CALL_CATCH_EXCEPTION(0); + } + return (void*)result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_Empty(void* accessibilityHighlightSignalTypeHandle) { + bool result; + Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType*) accessibilityHighlightSignalTypeHandle; + + if (accessibilityHighlightSignalType == nullptr) { + DALI_LOG_ERROR("[ERR] accessibilityHighlightSignalType == nullptr"); + return false; + } + + { + try { + result = accessibilityHighlightSignalType->Empty(); + } + CALL_CATCH_EXCEPTION(false); + } + return result; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_GetConnectionCount(void* accessibilityHighlightSignalTypeHandle) { + unsigned int result; + Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType *) accessibilityHighlightSignalTypeHandle; + + if (accessibilityHighlightSignalType == nullptr) { + DALI_LOG_ERROR("[ERR] accessibilityHighlightSignalType == nullptr"); + return 0; + } + + { + try { + result = accessibilityHighlightSignalType->GetConnectionCount(); + } + CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_Connect(void* accessibilityHighlightSignalTypeHandle, void* winHandle) { + Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType *)accessibilityHighlightSignalTypeHandle; + void (*window)(Dali::Window, bool) = ( void (*)(Dali::Window, bool) )winHandle; + + if (accessibilityHighlightSignalType == nullptr) { + DALI_LOG_ERROR("[ERR] accessibilityHighlightSignalType == nullptr"); + return ; + } + + { + try { + accessibilityHighlightSignalType->Connect(window); + } + CALL_CATCH_EXCEPTION(); + } + return ; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_Disconnect(void* accessibilityHighlightSignalTypeHandle, void* winHandle) { + Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType*)accessibilityHighlightSignalTypeHandle; + void (*window)(Dali::Window, bool) = (void (*)(Dali::Window, bool))winHandle; + + if (accessibilityHighlightSignalType == nullptr) { + DALI_LOG_ERROR("[ERR] accessibilityHighlightSignalType == nullptr"); + return; + } + + { + try { + accessibilityHighlightSignalType->Disconnect(window); + } + CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_delete(void* accessibilityHighlightSignalTypeHandle) { + Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType*)accessibilityHighlightSignalTypeHandle; + + { + try { + delete accessibilityHighlightSignalType; + } + CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_IsWindowRotating(void* winHandle) +{ + Dali::Window* window = (Dali::Window*)winHandle; + bool result = false; + if (!window) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return result; + } + { + try { + result = Dali::DevelWindow::IsWindowRotating(*window); + } CALL_CATCH_EXCEPTION(false); + } + + return result; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetLastKeyEvent(void* winHandle) +{ + Dali::Window* window = (Dali::Window*)winHandle; + void * jresult; + Dali::KeyEvent *result = 0; + if (!window) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + { + try { + result = (Dali::KeyEvent *)&Dali::DevelWindow::GetLastKeyEvent(*window); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetLastTouchEvent(void* winHandle) +{ + Dali::Window* window = (Dali::Window*)winHandle; + void * jresult; + Dali::TouchEvent *result = 0; + if (!window) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + { + try { + result = (Dali::TouchEvent *)&Dali::DevelWindow::GetLastTouchEvent(*window); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_InternalRetrievingLastKeyEvent(void* winHandle, void* keyHandle) +{ + Dali::Window* window = (Dali::Window*)winHandle; + Dali::KeyEvent* keyEvent = (Dali::KeyEvent*)keyHandle; + + if (!window) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return; + } + if (!keyEvent) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::KeyEvent", 0); + return; + } + { + try { + (*keyEvent) = *((Dali::KeyEvent *)&Dali::DevelWindow::GetLastKeyEvent(*window)); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_InternalRetrievingLastTouchEvent(void* winHandle, void* touchHandle) +{ + Dali::Window* window = (Dali::Window*)winHandle; + Dali::TouchEvent* touchEvent = (Dali::TouchEvent*)touchHandle; + + if (!window) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return; + } + if (!touchEvent) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TouchEvent", 0); + return; + } + { + try { + (*touchEvent) = *((Dali::TouchEvent *)&Dali::DevelWindow::GetLastTouchEvent(*window)); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetNeedsRotationCompletedAcknowledgement(void* winHandle, bool needAcknowledgement) +{ + Dali::Window* window = (Dali::Window*)winHandle; + if (!window) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return; + } + { + try { + Dali::DevelWindow::SetNeedsRotationCompletedAcknowledgement(*window, needAcknowledgement); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SendRotationCompletedAcknowledgement(void* winHandle) +{ + Dali::Window* window = (Dali::Window*)winHandle; + if (!window) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return; + } + { + try { + Dali::DevelWindow::SendRotationCompletedAcknowledgement(*window); + } CALL_CATCH_EXCEPTION(); + } +} + +/* Moved signal binding */ +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Moved_Signal(void* winHandle) +{ + void *result; + Dali::Window window; + Dali::Window *win; + Dali::DevelWindow::MovedSignalType* movedSignal; + + win = (Dali::Window *)winHandle; + if (!win) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + window = *win; + { + try { + movedSignal = (Dali::DevelWindow::MovedSignalType *) &Dali::DevelWindow::MovedSignal(window); + } CALL_CATCH_EXCEPTION(0); + } + + result = (void *)movedSignal; + return result; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Moved_Signal_Empty(void * signal) +{ + unsigned int result; + Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; + bool flag; + + movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; + { + try { + flag = (bool)Dali_Signal_Window_Moved_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *)movedSignal); + } CALL_CATCH_EXCEPTION(0); + } + + result = (unsigned int)flag; + return result; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Moved_Signal_GetConnectionCount(void * signal) { + unsigned long result; + Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; + std::size_t count; + + movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; + { + try { + count = Dali_Signal_Window_Moved_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *)movedSignal); + } CALL_CATCH_EXCEPTION(0); + } + + result = (unsigned long)count; + return result; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Moved_Signal_Connect(void * signal, void * func) { + Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; + void (*functionPtr)(Dali::Window, Dali::Window::WindowPosition) = (void (*)(Dali::Window, Dali::Window::WindowPosition)) 0 ; + + movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; + functionPtr = (void (*)(Dali::Window, Dali::Window::WindowPosition))func; + { + try { + Dali_Signal_Window_Moved_Signal_Connect(movedSignal, functionPtr); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Moved_Signal_Disconnect(void * signal, void * func) { + Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; + void (*functionPtr)(Dali::Window, Dali::Window::WindowPosition) = (void (*)(Dali::Window, Dali::Window::WindowPosition)) 0 ; + + movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; + functionPtr = (void (*)(Dali::Window, Dali::Window::WindowPosition))func; + { + try { + Dali_Signal_Window_Moved_Signal_Disconnect(movedSignal, functionPtr); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Moved_Signal_Emit(void * signal, void* winHandle, void * position) { + Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; + Dali::Window* win = (Dali::Window*)winHandle; + Dali::Window window; + Dali::Window::WindowPosition windowPosition; + Dali::Window::WindowPosition *pPosition; + + movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; + if (movedSignal == nullptr || window == nullptr) { + DALI_LOG_ERROR("[ERR] movedSignal == nullptr or window == nullptr"); + return; + } + + pPosition = (Dali::Window::WindowPosition *)position; + if (!pPosition) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); + return ; + } + window = *win; + windowPosition = *pPosition; + { + try { + Dali_Signal_Window_Moved_Signal_Emit(movedSignal, window, windowPosition); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Moved_Signal() { + void * result ; + Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = 0 ; + + { + try { + movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)new Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) >(); + } CALL_CATCH_EXCEPTION(0); + } + + result = (void *)movedSignal; + return result; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Moved_Signal(void * signal) { + Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; + + movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; + { + try { + delete movedSignal; + } CALL_CATCH_EXCEPTION(); + } + +} + +/* Orientation Changed signal binding */ +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Orientation_Changed_Signal(void* winHandle) +{ + void *result; + Dali::Window window; + Dali::Window *win; + Dali::DevelWindow::OrientationChangedSignalType* orientationChangedSignal; + + win = (Dali::Window *)winHandle; + if (!win) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + window = *win; + { + try { + orientationChangedSignal = (Dali::DevelWindow::OrientationChangedSignalType *) &Dali::DevelWindow::OrientationChangedSignal(window); + } CALL_CATCH_EXCEPTION(0); + } + + result = (void *)orientationChangedSignal; + return result; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Orientation_Changed_Signal_Empty(void * signal) +{ + unsigned int result; + Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ; + bool flag; + + orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal; + { + try { + flag = (bool)Dali_Signal_Window_Orientation_Changed_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > const *)orientationChangedSignal); + } CALL_CATCH_EXCEPTION(0); + } + + result = (unsigned int)flag; + return result; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Orientation_Changed_Signal_GetConnectionCount(void * signal) { + unsigned long result; + Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ; + std::size_t count; + + orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal; + { + try { + count = Dali_Signal_Window_Orientation_Changed_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > const *)orientationChangedSignal); + } CALL_CATCH_EXCEPTION(0); + } + + result = (unsigned long)count; + return result; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Orientation_Changed_Signal_Connect(void * signal, void * func) { + Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ; + void (*functionPtr)(Dali::Window, Dali::WindowOrientation) = (void (*)(Dali::Window, Dali::WindowOrientation)) 0 ; + + orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal; + functionPtr = (void (*)(Dali::Window, Dali::WindowOrientation))func; + { + try { + Dali_Signal_Window_Orientation_Changed_Signal_Connect(orientationChangedSignal, functionPtr); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Orientation_Changed_Signal_Disconnect(void * signal, void * func) { + Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ; + void (*functionPtr)(Dali::Window, Dali::WindowOrientation) = (void (*)(Dali::Window, Dali::WindowOrientation)) 0 ; + + orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal; + functionPtr = (void (*)(Dali::Window, Dali::WindowOrientation))func; + { + try { + Dali_Signal_Window_Orientation_Changed_Signal_Disconnect(orientationChangedSignal, functionPtr); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Orientation_Changed_Signal_Emit(void * signal, void* winHandle, int orientation) { + Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ; + Dali::Window* win = (Dali::Window*)winHandle; + Dali::Window window; + Dali::WindowOrientation windowOrientation; + + orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal; + if (orientationChangedSignal == nullptr || window == nullptr) { + DALI_LOG_ERROR("[ERR] orientationChangedSignal == nullptr or window == nullptr"); + return; + } + + window = *win; + windowOrientation = static_cast(orientation); + { + try { + Dali_Signal_Window_Orientation_Changed_Signal_Emit(orientationChangedSignal, window, windowOrientation); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Orientation_Changed_Signal() { + void * result ; + Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = 0 ; + + { + try { + orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)new Dali::Signal< void (Dali::Window, Dali::WindowOrientation) >(); + } CALL_CATCH_EXCEPTION(0); + } + + result = (void *)orientationChangedSignal; + return result; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Orientation_Changed_Signal(void * signal) { + Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ; + + orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal; + { + try { + delete orientationChangedSignal; + } CALL_CATCH_EXCEPTION(); + } + +} + +// +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal(void* winHandle) +{ + void *result; + Dali::Window window; + Dali::Window *win; + Dali::DevelWindow::MouseInOutEventSignalType* mouseInOutSignal; + + win = (Dali::Window *)winHandle; + if (!win) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + window = *win; + { + try { + mouseInOutSignal = (Dali::DevelWindow::MouseInOutEventSignalType *) &Dali::DevelWindow::MouseInOutEventSignal(window); + } CALL_CATCH_EXCEPTION(0); + } + + result = (void *)mouseInOutSignal; + return result; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Window_MouseInOutEvent_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1; + { + try { + result = Dali_Signal_Window_MouseInOutEvent_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ; + void (*arg2)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) = (void (*)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1; + arg2 = (void (*)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &))jarg2; + { + try { + Dali_Signal_Window_MouseInOutEvent_Signal_Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ; + void (*arg2)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) = (void (*)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1; + arg2 = (void (*)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &))jarg2; + { + try { + Dali_Signal_Window_MouseInOutEvent_Signal_Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_Emit(void * jarg1, void* jarg2, void* jarg3) { + Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1; + Dali::Window* arg2 = (Dali::Window*)jarg2; + Dali::DevelWindow::MouseInOutEvent* arg3 = (Dali::DevelWindow::MouseInOutEvent*)jarg3; + + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Signal", 0); + return ; + } + + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return ; + } + + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DevelWindow::MouseInOutEvent", 0); + return ; + } + + { + try { + Dali_Signal_Window_MouseInOutEvent_Signal_Emit(arg1,*arg2,*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowMouseInOutEventSignal() { + void * jresult ; + Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)new Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowMouseInOutEventSignal(void * jarg1) { + Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_MouseInOutEvent__SWIG_0(int jarg1, unsigned int jarg2, void * jarg3, unsigned int jarg4) { + void * jresult ; + Dali::DevelWindow::MouseInOutEvent::Type arg1 ; + unsigned int arg2 ; + Dali::Vector2 arg3 ; + unsigned int arg4 ; + + Dali::Vector2 *argp3 ; + + Dali::DevelWindow::MouseInOutEvent *result = 0; + + arg1 = static_cast(jarg1); + arg2 = (unsigned int)jarg2; + argp3 = (Dali::Vector2 *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); + return 0; + } + arg3 = *argp3; + arg4 = (unsigned int)jarg4; + { + try { + result = (Dali::DevelWindow::MouseInOutEvent *)new Dali::DevelWindow::MouseInOutEvent(arg1, arg2, arg3, arg4, Dali::Device::Class::NONE, Dali::Device::Subclass::NONE); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MouseInOutEvent(void * jarg1) { + Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ; + + arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_type_get(void * jarg1) { + int jresult ; + Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ; + Dali::DevelWindow::MouseInOutEvent::Type result; + + arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1; + { + try { + result = ((Dali::DevelWindow::MouseInOutEvent const *)arg1)->type; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_modifiers_get(void * jarg1) { + unsigned int jresult ; + Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ; + unsigned int result; + + arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1; + { + try { + result = ((Dali::DevelWindow::MouseInOutEvent const *)arg1)->modifiers; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MouseInOutEvent_point_get(void * jarg1) { + void * jresult ; + Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1; + { + try { + result = (Dali::Vector2 *) &((Dali::DevelWindow::MouseInOutEvent const *)arg1)->point; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_timeStamp_get(void * jarg1) { + unsigned int jresult ; + Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ; + unsigned int result; + + arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1; + { + try { + result = ((Dali::DevelWindow::MouseInOutEvent const *)arg1)->timeStamp; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_GetDeviceClass(void * jarg1) { + int jresult ; + Dali::DevelWindow::MouseInOutEvent *arg1 = 0 ; + Dali::Device::Class::Type result; + + arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelWindow::MouseInOutEvent const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Device::Class::Type)arg1->deviceClass; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_GetDeviceSubClass(void * jarg1) { + int jresult ; + Dali::DevelWindow::MouseInOutEvent *arg1 = 0 ; + Dali::Device::Subclass::Type result; + + arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelWindow::MouseInOutEvent const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Device::Subclass::Type)arg1->deviceSubclass; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +/* Move Completed signal binding */ +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Move_Completed_Signal(void* winHandle) +{ + void *result; + Dali::Window window; + Dali::Window *win; + Dali::DevelWindow::MoveCompletedSignalType* moveCompletedSignal; + + win = (Dali::Window *)winHandle; + if (!win) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + window = *win; + { + try { + moveCompletedSignal = (Dali::DevelWindow::MoveCompletedSignalType *) &Dali::DevelWindow::MoveCompletedSignal(window); + } CALL_CATCH_EXCEPTION(0); + } + + result = (void *)moveCompletedSignal; + return result; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Move_Completed_Signal_Empty(void * signal) +{ + unsigned int result; + Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; + bool flag; + + moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; + { + try { + flag = (bool)Dali_Signal_Window_Move_Completed_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *)moveCompletedSignal); + } CALL_CATCH_EXCEPTION(0); + } + + result = (unsigned int)flag; + return result; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Move_Completed_Signal_GetConnectionCount(void * signal) { + unsigned long result; + Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; + std::size_t count; + + moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; + { + try { + count = Dali_Signal_Window_Move_Completed_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *)moveCompletedSignal); + } CALL_CATCH_EXCEPTION(0); + } + + result = (unsigned long)count; + return result; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Move_Completed_Signal_Connect(void * signal, void * func) { + Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; + void (*functionPtr)(Dali::Window, Dali::Window::WindowPosition) = (void (*)(Dali::Window, Dali::Window::WindowPosition)) 0 ; + + moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; + functionPtr = (void (*)(Dali::Window, Dali::Window::WindowPosition))func; + { + try { + Dali_Signal_Window_Move_Completed_Signal_Connect(moveCompletedSignal, functionPtr); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Move_Completed_Signal_Disconnect(void * signal, void * func) { + Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; + void (*functionPtr)(Dali::Window, Dali::Window::WindowPosition) = (void (*)(Dali::Window, Dali::Window::WindowPosition)) 0 ; + + moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; + functionPtr = (void (*)(Dali::Window, Dali::Window::WindowPosition))func; + { + try { + Dali_Signal_Window_Move_Completed_Signal_Disconnect(moveCompletedSignal, functionPtr); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Move_Completed_Signal_Emit(void * signal, void* winHandle, void * position) { + Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; + Dali::Window* win = (Dali::Window*)winHandle; + Dali::Window window; + Dali::Window::WindowPosition windowPosition; + Dali::Window::WindowPosition *pPosition; + + moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; + if (moveCompletedSignal == nullptr || window == nullptr) { + DALI_LOG_ERROR("[ERR] moveCompletedSignal == nullptr or window == nullptr"); + return; + } + + pPosition = (Dali::Window::WindowPosition *)position; + if (!pPosition) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); + return ; + } + window = *win; + windowPosition = *pPosition; + { + try { + Dali_Signal_Window_Move_Completed_Signal_Emit(moveCompletedSignal, window, windowPosition); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Move_Completed_Signal() { + void * result ; + Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = 0 ; + + { + try { + moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)new Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) >(); + } CALL_CATCH_EXCEPTION(0); + } + + result = (void *)moveCompletedSignal; + return result; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Move_Completed_Signal(void * signal) { + Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; + + moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; + { + try { + delete moveCompletedSignal; + } CALL_CATCH_EXCEPTION(); + } + +} + +/* Resized Completed signal binding */ +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Resize_Completed_Signal(void* winHandle) +{ + void *result; + Dali::Window window; + Dali::Window *win; + Dali::DevelWindow::ResizeCompletedSignalType* resizeCompletedSignal; + + win = (Dali::Window *)winHandle; + if (!win) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); + return 0; + } + window = *win; + { + try { + resizeCompletedSignal = (Dali::DevelWindow::ResizeCompletedSignalType *) &Dali::DevelWindow::ResizeCompletedSignal(window); + } CALL_CATCH_EXCEPTION(0); + } + + result = (void *)resizeCompletedSignal; + return result; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Resize_Completed_Signal_Empty(void * signal) +{ + unsigned int result; + Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; + bool flag; + + resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal; + { + try { + flag = (bool)Dali_Signal_Window_Resize_Completed_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *)resizeCompletedSignal); + } CALL_CATCH_EXCEPTION(0); + } + + result = (unsigned int)flag; + return result; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Resize_Completed_Signal_GetConnectionCount(void * signal) { + unsigned long result; + Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; + std::size_t count; + + resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal; + { + try { + count = Dali_Signal_Window_Resize_Completed_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *)resizeCompletedSignal); + } CALL_CATCH_EXCEPTION(0); + } + + result = (unsigned long)count; + return result; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Resize_Completed_Signal_Connect(void * signal, void * func) { + Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; + void (*functionPtr)(Dali::Window, Dali::Window::WindowSize) = (void (*)(Dali::Window, Dali::Window::WindowSize)) 0 ; + + resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal; + functionPtr = (void (*)(Dali::Window, Dali::Window::WindowSize))func; + { + try { + Dali_Signal_Window_Resize_Completed_Signal_Connect(resizeCompletedSignal, functionPtr); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Resize_Completed_Signal_Disconnect(void * signal, void * func) { + Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; + void (*functionPtr)(Dali::Window, Dali::Window::WindowSize) = (void (*)(Dali::Window, Dali::Window::WindowSize)) 0 ; + + resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal; + functionPtr = (void (*)(Dali::Window, Dali::Window::WindowSize))func; + { + try { + Dali_Signal_Window_Resize_Completed_Signal_Disconnect(resizeCompletedSignal, functionPtr); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Resize_Completed_Signal_Emit(void * signal, void* winHandle, void * size) { + Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; + Dali::Window* win = (Dali::Window*)winHandle; + Dali::Window window; + Dali::Window::WindowSize windowSize; + Dali::Window::WindowSize *pSize; + + resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal; + if (resizeCompletedSignal == nullptr || window == nullptr) { + DALI_LOG_ERROR("[ERR] resizeCompletedSignal == nullptr or window == nullptr"); + return; + } + + pSize = (Dali::Window::WindowSize *)size; + if (!pSize) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); + return ; + } + window = *win; + windowSize = *pSize; + { + try { + Dali_Signal_Window_Resize_Completed_Signal_Emit(resizeCompletedSignal, window, windowSize); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Resize_Completed_Signal() { + void * result ; + Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = 0 ; + + { + try { + resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)new Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) >(); + } CALL_CATCH_EXCEPTION(0); + } + + result = (void *)resizeCompletedSignal; + return result; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Resize_Completed_Signal(void * signal) { + Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; + + resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal; + { + try { + delete resizeCompletedSignal; + } CALL_CATCH_EXCEPTION(); + } + +} + + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-core/actor-wrap.cpp b/dali-csharp-binder/dali-core/actor-wrap.cpp new file mode 100644 index 00000000..a0a2fe3c --- /dev/null +++ b/dali-csharp-binder/dali-core/actor-wrap.cpp @@ -0,0 +1,3896 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +// SWIGINTERN - the relevant parts of the generated code can be seen the below. + +SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal const* self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal const* self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal* self, bool (*func)(Dali::Actor, Dali::TouchEvent const&)) +{ + self->Connect(func); +} +SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal* self, bool (*func)(Dali::Actor, Dali::TouchEvent const&)) +{ + self->Disconnect(func); +} +SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal* self, Dali::Actor arg1, Dali::TouchEvent const& arg2) +{ + return self->Emit(arg1, arg2); +} +SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal const* self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal const* self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal* self, bool (*func)(Dali::Actor, Dali::HoverEvent const&)) +{ + self->Connect(func); +} +SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal* self, bool (*func)(Dali::Actor, Dali::HoverEvent const&)) +{ + self->Disconnect(func); +} +SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal* self, Dali::Actor arg1, Dali::HoverEvent const& arg2) +{ + return self->Emit(arg1, arg2); +} +SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal const* self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal const* self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal* self, bool (*func)(Dali::Actor, Dali::WheelEvent const&)) +{ + self->Connect(func); +} +SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal* self, bool (*func)(Dali::Actor, Dali::WheelEvent const&)) +{ + self->Disconnect(func); +} +SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal* self, Dali::Actor arg1, Dali::WheelEvent const& arg2) +{ + return self->Emit(arg1, arg2); +} +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal const* self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal const* self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal* self, void (*func)(Dali::Actor)) +{ + self->Connect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal* self, void (*func)(Dali::Actor)) +{ + self->Disconnect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal* self, Dali::Actor arg) +{ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; + /*@SWIG@*/ self->Emit(arg); +} + +using namespace Dali; + +#ifdef __cplusplus +extern "C" { +#endif + +// Property + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::PARENT_ORIGIN; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::PARENT_ORIGIN_X; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::ANCHOR_POINT; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::ANCHOR_POINT_X; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::ANCHOR_POINT_Y; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::ANCHOR_POINT_Z; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::SIZE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::SIZE_WIDTH; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::SIZE_HEIGHT; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::SIZE_DEPTH; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::POSITION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::POSITION_X; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::POSITION_Y; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::POSITION_Z; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::WORLD_POSITION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::WORLD_POSITION_X; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::WORLD_POSITION_Y; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::WORLD_POSITION_Z; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::ORIENTATION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::WORLD_ORIENTATION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::SCALE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::SCALE_X; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::SCALE_Y; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::SCALE_Z; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::WORLD_SCALE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::VISIBLE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::COLOR; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::COLOR_RED; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::COLOR_GREEN; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::COLOR_BLUE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::COLOR_ALPHA; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::WORLD_COLOR; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::WORLD_MATRIX; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::NAME; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::SENSITIVE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_USER_INTERACTION_ENABLED_get() +{ + int jresult; + int result; + + result = (int)Dali::DevelActor::Property::USER_INTERACTION_ENABLED; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::LEAVE_REQUIRED; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::INHERIT_ORIENTATION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::INHERIT_SCALE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::COLOR_MODE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::DRAW_MODE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::PADDING; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::MINIMUM_SIZE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::MAXIMUM_SIZE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::INHERIT_POSITION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::CLIPPING_MODE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_UPDATE_AREA_HINT_get() +{ + int jresult; + int result; + + result = (int)Dali::Actor::Property::UPDATE_AREA_HINT; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() +{ + return Dali::Actor::Property::OPACITY; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() +{ + return Dali::Actor::Property::SCREEN_POSITION; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() +{ + return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() +{ + return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() +{ + return Dali::Actor::Property::LAYOUT_DIRECTION; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CULLED_get() +{ + return Dali::Actor::Property::CULLED; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SIBLING_ORDER_get() +{ + return Dali::DevelActor::Property::SIBLING_ORDER; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_CAPTURE_ALL_TOUCH_AFTER_START_get() +{ + return Dali::DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_ALLOW_ONLY_OWN_TOUCH_get() +{ + return Dali::DevelActor::Property::ALLOW_ONLY_OWN_TOUCH; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_BLEND_EQUATION_get() +{ + return Dali::DevelActor::Property::BLEND_EQUATION; +} + +// Creation + +SWIGEXPORT Dali::Handle* SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor* jarg1) +{ + return (Dali::Handle*)jarg1; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Actor_Property() +{ + void* jresult; + Dali::Actor::Property* result = 0; + + { + try + { + result = (Dali::Actor::Property*)new Dali::Actor::Property(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void* jarg1) +{ + Dali::Actor::Property* arg1 = (Dali::Actor::Property*)0; + + arg1 = (Dali::Actor::Property*)jarg1; + { + try + { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() +{ + void* jresult; + Dali::Actor* result = 0; + + { + try + { + result = (Dali::Actor*)new Dali::Actor(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_New() +{ + void* jresult; + Dali::Actor result; + + { + try + { + result = Dali::Actor::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_DownCast(void* jarg1) +{ + void* jresult; + Dali::BaseHandle arg1; + Dali::BaseHandle* argp1; + Dali::Actor 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::Actor::DownCast(arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor&)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void* jarg1) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + + arg1 = (Dali::Actor*)jarg1; + { + try + { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = 0; + Dali::Actor* result = 0; + + arg1 = (Dali::Actor*)jarg1; + if(!arg1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Actor*)new Dali::Actor((Dali::Actor const&)*arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_Assign(void* jarg1, void* jarg2) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Actor* arg2 = 0; + Dali::Actor* result = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + if(!jarg2) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Actor*)jarg2; + { + try + { + result = (Dali::Actor*)&(arg1)->operator=((Dali::Actor const&)*arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +// Method + +SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Actor_GetName(void* jarg1) +{ + char* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + std::string* result = 0; + std::string name = ""; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + name = ((Dali::Actor const*)arg1)->GetProperty(Dali::Actor::Property::NAME); + result = (std::string*)&name; + jresult = SWIG_csharp_string_callback(result->c_str()); + } + CALL_CATCH_EXCEPTION(0); + } + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void* jarg1, char* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + std::string* arg2 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + if(!jarg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try + { + (arg1)->SetProperty(Dali::Actor::Property::NAME, (std::string const&)*arg2); + } + CALL_CATCH_EXCEPTION(); + } + + //argout typemap for const std::string& +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void* jarg1) +{ + unsigned int jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + unsigned int result; + + arg1 = (Dali::Actor*)jarg1; + + if(!arg1) + { + DALI_LOG_ERROR("[ERROR] actor is null! return -1"); + return -1; + } + + { + try + { + result = (unsigned int)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::ID); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void* jarg1) +{ + bool jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + bool result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (bool)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::IS_ROOT); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_OnStage(void* jarg1) +{ + bool jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + bool result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (bool)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::CONNECTED_TO_SCENE); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void* jarg1) +{ + bool jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + bool result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (bool)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::IS_LAYER); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Layer result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (arg1)->GetLayer(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Layer((const Dali::Layer&)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void* jarg1, void* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Actor arg2; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + if(!jarg2) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = *((Dali::Actor*)jarg2); + { + try + { + (arg1)->Add(arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void* jarg1, void* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Actor arg2; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + if(!jarg2) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = *((Dali::Actor*)jarg2); + { + try + { + (arg1)->Remove(arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void* jarg1) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + (arg1)->Unparent(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void* jarg1) +{ + unsigned int jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + unsigned int result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (unsigned int)((Dali::Actor const*)arg1)->GetChildCount(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void* jarg1, unsigned int jarg2) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + unsigned int arg2; + Dali::Actor result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (unsigned int)jarg2; + { + try + { + result = ((Dali::Actor const*)arg1)->GetChildAt(arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void* jarg1, char* jarg2) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + std::string* arg2 = 0; + Dali::Actor result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + if(!jarg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try + { + result = (arg1)->FindChildByName((std::string const&)*arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor&)result); + + //argout typemap for const std::string& + + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void* jarg1, unsigned int jarg2) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + unsigned int arg2; + Dali::Actor result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (unsigned int)jarg2; + { + try + { + result = (arg1)->FindChildById(arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetParent(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Actor result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = ((Dali::Actor const*)arg1)->GetParent(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor&)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void* jarg1, void* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector3* arg2 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Vector3*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return; + } + { + try + { + (arg1)->SetProperty(Actor::Property::PARENT_ORIGIN, (Dali::Vector3 const&)*arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector3 result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::PARENT_ORIGIN); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3&)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void* jarg1, void* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector3* arg2 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Vector3*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return; + } + { + try + { + (arg1)->SetProperty(Actor::Property::ANCHOR_POINT, (Dali::Vector3 const&)*arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector3 result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::ANCHOR_POINT); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3&)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void* jarg1, float jarg2, float jarg3) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + float arg2; + float arg3; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + { + try + { + (arg1)->SetProperty(Actor::Property::SIZE, Dali::Vector2(arg2, arg3)); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void* jarg1, float jarg2, float jarg3, float jarg4) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + float arg2; + float arg3; + float arg4; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + { + try + { + (arg1)->SetProperty(Actor::Property::SIZE, Dali::Vector3(arg2, arg3, arg4)); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void* jarg1, void* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector2* arg2 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Vector2*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return; + } + { + try + { + (arg1)->SetProperty(Actor::Property::SIZE, (Dali::Vector2 const&)*arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void* jarg1, void* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector3* arg2 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Vector3*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return; + } + { + try + { + (arg1)->SetProperty(Actor::Property::SIZE, (Dali::Vector3 const&)*arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector3 result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = ((Dali::Actor const*)arg1)->GetTargetSize(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector3 result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::SIZE); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector3 result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = ((Dali::Actor const*)arg1)->GetNaturalSize(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3&)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void* jarg1, float jarg2, float jarg3) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + float arg2; + float arg3; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + { + try + { + (arg1)->SetProperty(Actor::Property::POSITION, Dali::Vector2(arg2, arg3)); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void* jarg1, float jarg2, float jarg3, float jarg4) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + float arg2; + float arg3; + float arg4; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + { + try + { + (arg1)->SetProperty(Actor::Property::POSITION, Dali::Vector3(arg2, arg3, arg4)); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void* jarg1, void* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector3* arg2 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Vector3*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return; + } + { + try + { + (arg1)->SetProperty(Actor::Property::POSITION, (Dali::Vector3 const&)*arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void* jarg1, float jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + float arg2; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (float)jarg2; + { + try + { + (arg1)->SetProperty(Actor::Property::POSITION_X, (arg2)); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void* jarg1, float jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + float arg2; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (float)jarg2; + { + try + { + (arg1)->SetProperty(Actor::Property::POSITION_Y, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void* jarg1, float jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + float arg2; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (float)jarg2; + { + try + { + (arg1)->SetProperty(Actor::Property::POSITION_Z, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void* jarg1, void* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector3* arg2 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Vector3*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return; + } + { + try + { + (arg1)->TranslateBy((Dali::Vector3 const&)*arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector3 result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::POSITION); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector3 result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::WORLD_POSITION); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3&)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void* jarg1, bool jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + bool arg2; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = jarg2 ? true : false; + { + try + { + (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void* jarg1) +{ + bool jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + bool result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (bool)((Dali::Actor const*)arg1)->GetProperty(Dali::Actor::Property::INHERIT_POSITION); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void* jarg1, void* jarg2, void* jarg3) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Degree* arg2 = 0; + Dali::Vector3* arg3 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Degree*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0); + return; + } + arg3 = (Dali::Vector3*)jarg3; + if(!arg3) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return; + } + { + try + { + (arg1)->SetProperty(Actor::Property::ORIENTATION, Quaternion((Dali::Degree const&)*arg2, (Dali::Vector3 const&)*arg3)); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void* jarg1, void* jarg2, void* jarg3) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Radian* arg2 = 0; + Dali::Vector3* arg3 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Radian*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0); + return; + } + arg3 = (Dali::Vector3*)jarg3; + if(!arg3) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return; + } + { + try + { + (arg1)->SetProperty(Actor::Property::ORIENTATION, Quaternion((Dali::Radian const&)*arg2, (Dali::Vector3 const&)*arg3)); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void* jarg1, void* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Quaternion* arg2 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Quaternion*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return; + } + { + try + { + (arg1)->SetProperty(Actor::Property::ORIENTATION, (Dali::Quaternion const&)*arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void* jarg1, void* jarg2, void* jarg3) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Degree* arg2 = 0; + Dali::Vector3* arg3 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Degree*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0); + return; + } + arg3 = (Dali::Vector3*)jarg3; + if(!arg3) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return; + } + { + try + { + (arg1)->RotateBy((Dali::Degree const&)*arg2, (Dali::Vector3 const&)*arg3); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void* jarg1, void* jarg2, void* jarg3) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Radian* arg2 = 0; + Dali::Vector3* arg3 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Radian*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0); + return; + } + arg3 = (Dali::Vector3*)jarg3; + if(!arg3) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return; + } + { + try + { + (arg1)->RotateBy((Dali::Radian const&)*arg2, (Dali::Vector3 const&)*arg3); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void* jarg1, void* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Quaternion* arg2 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Quaternion*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return; + } + { + try + { + (arg1)->RotateBy((Dali::Quaternion const&)*arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Quaternion result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::ORIENTATION); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Quaternion((const Dali::Quaternion&)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void* jarg1, bool jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + bool arg2; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = jarg2 ? true : false; + { + try + { + (arg1)->SetProperty(Actor::Property::INHERIT_ORIENTATION, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void* jarg1) +{ + bool jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + bool result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (bool)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::INHERIT_ORIENTATION); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Quaternion result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::WORLD_ORIENTATION); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Quaternion((const Dali::Quaternion&)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void* jarg1, float jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + float arg2; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (float)jarg2; + { + try + { + (arg1)->SetProperty(Actor::Property::SCALE, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void* jarg1, float jarg2, float jarg3, float jarg4) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + float arg2; + float arg3; + float arg4; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + { + try + { + (arg1)->SetProperty(Actor::Property::SCALE, Vector3(arg2, arg3, arg4)); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void* jarg1, void* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector3* arg2 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Vector3*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return; + } + { + try + { + (arg1)->SetProperty(Actor::Property::SCALE, (Dali::Vector3 const&)*arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void* jarg1, void* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector3* arg2 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Vector3*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return; + } + { + try + { + (arg1)->ScaleBy((Dali::Vector3 const&)*arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector3 result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::SCALE); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector3 result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::WORLD_SCALE); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3&)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void* jarg1, bool jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + bool arg2; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = jarg2 ? true : false; + { + try + { + (arg1)->SetProperty(Actor::Property::INHERIT_SCALE, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void* jarg1) +{ + bool jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + bool result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (bool)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::INHERIT_SCALE); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Matrix result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::WORLD_MATRIX); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Matrix((const Dali::Matrix&)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void* jarg1) +{ + Dali::Actor arg1; + Dali::Actor* argp1; + + argp1 = (Dali::Actor*)jarg1; + if(!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return; + } + arg1 = *argp1; + { + try + { + arg1.Raise(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void* jarg1) +{ + Dali::Actor arg1; + Dali::Actor* argp1; + + argp1 = (Dali::Actor*)jarg1; + if(!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return; + } + arg1 = *argp1; + { + try + { + arg1.Lower(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void* jarg1) +{ + Dali::Actor arg1; + Dali::Actor* argp1; + + argp1 = (Dali::Actor*)jarg1; + if(!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return; + } + arg1 = *argp1; + { + try + { + arg1.RaiseToTop(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void* jarg1) +{ + Dali::Actor arg1; + Dali::Actor* argp1; + + argp1 = (Dali::Actor*)jarg1; + if(!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return; + } + arg1 = *argp1; + { + try + { + arg1.LowerToBottom(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void* jarg1, void* jarg2) +{ + Dali::Actor arg1; + Dali::Actor arg2; + Dali::Actor* argp1; + Dali::Actor* argp2; + + argp1 = (Dali::Actor*)jarg1; + if(!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return; + } + arg1 = *argp1; + argp2 = (Dali::Actor*)jarg2; + if(!argp2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return; + } + arg2 = *argp2; + { + try + { + arg1.RaiseAbove(arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void* jarg1, void* jarg2) +{ + Dali::Actor arg1; + Dali::Actor arg2; + Dali::Actor* argp1; + Dali::Actor* argp2; + + argp1 = (Dali::Actor*)jarg1; + if(!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return; + } + arg1 = *argp1; + argp2 = (Dali::Actor*)jarg2; + if(!argp2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return; + } + arg2 = *argp2; + { + try + { + arg1.LowerBelow(arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void* jarg1, bool jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + bool arg2; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = jarg2 ? true : false; + { + try + { + (arg1)->SetProperty(Actor::Property::VISIBLE, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void* jarg1) +{ + bool jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + bool result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (bool)((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::VISIBLE); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void* jarg1, float jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + float arg2; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (float)jarg2; + { + try + { + (arg1)->SetProperty(Actor::Property::OPACITY, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void* jarg1) +{ + float jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + float result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (float)((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::OPACITY); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void* jarg1, void* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector4* arg2 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Vector4*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return; + } + { + try + { + (arg1)->SetProperty(Actor::Property::COLOR, (Dali::Vector4 const&)*arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector4 result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::COLOR); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4&)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void* jarg1, int jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::ColorMode arg2; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::ColorMode)jarg2; + { + try + { + (arg1)->SetProperty(Actor::Property::COLOR_MODE, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void* jarg1) +{ + int jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::ColorMode result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (Dali::ColorMode)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::COLOR_MODE); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector4 result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::WORLD_COLOR); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4&)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void* jarg1, int jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::DrawMode::Type arg2; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::DrawMode::Type)jarg2; + { + try + { + (arg1)->SetProperty(Actor::Property::DRAW_MODE, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void* jarg1) +{ + int jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::DrawMode::Type result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (Dali::DrawMode::Type)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::DRAW_MODE); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void* jarg1, bool jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + bool arg2; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = jarg2 ? true : false; + { + try + { + (arg1)->SetProperty(Actor::Property::SENSITIVE, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void* jarg1) +{ + bool jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + bool result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (bool)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::SENSITIVE); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void* jarg1, float* jarg2, float* jarg3, float jarg4, float jarg5) +{ + bool jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + float* arg2 = 0; + float* arg3 = 0; + float arg4; + float arg5; + bool result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (float*)jarg2; + arg3 = (float*)jarg3; + arg4 = (float)jarg4; + arg5 = (float)jarg5; + { + try + { + result = (bool)((Dali::Actor const*)arg1)->ScreenToLocal(*arg2, *arg3, arg4, arg5); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void* jarg1, bool jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + bool arg2; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = jarg2 ? true : false; + { + try + { + (arg1)->SetProperty(Actor::Property::LEAVE_REQUIRED, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void* jarg1) +{ + bool jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + bool result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (bool)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::LEAVE_REQUIRED); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void* jarg1, bool jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + bool arg2; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = jarg2 ? true : false; + { + try + { + (arg1)->SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void* jarg1) +{ + bool jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + bool result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (bool)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::KEYBOARD_FOCUSABLE); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusableChildren(void* actor, bool keyboardFocusableChildren) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + + if(!actor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return; + } + + arg1 = (Dali::Actor*)actor; + { + try + { + (arg1)->SetProperty(DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN, keyboardFocusableChildren); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_AreChildrenKeyBoardFocusable(void* actor) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + bool result; + + if(!actor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return 0; + } + + arg1 = (Dali::Actor*)actor; + { + try + { + result = (bool)((Dali::Actor const*)arg1)->GetProperty(DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN); + } + CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetTouchFocusable(void* jarg1, bool jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + bool arg2; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = jarg2 ? true : false; + { + try + { + (arg1)->SetProperty(DevelActor::Property::TOUCH_FOCUSABLE, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsTouchFocusable(void* jarg1) +{ + bool jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + bool result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (bool)((Dali::Actor const*)arg1)->GetProperty(DevelActor::Property::TOUCH_FOCUSABLE); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void* jarg1, int jarg2, int jarg3) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::ResizePolicy::Type arg2; + Dali::Dimension::Type arg3; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::ResizePolicy::Type)jarg2; + arg3 = (Dali::Dimension::Type)jarg3; + { + try + { + (arg1)->SetResizePolicy(arg2, arg3); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void* jarg1, int jarg2) +{ + int jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Dimension::Type arg2; + Dali::ResizePolicy::Type result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Dimension::Type)jarg2; + { + try + { + result = (Dali::ResizePolicy::Type)((Dali::Actor const*)arg1)->GetResizePolicy(arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void* jarg1, int jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::SizeScalePolicy::Type arg2; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::SizeScalePolicy::Type)jarg2; + { + try + { + (arg1)->SetProperty(Actor::Property::SIZE_SCALE_POLICY, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void* jarg1) +{ + int jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::SizeScalePolicy::Type result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (Dali::SizeScalePolicy::Type)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::SIZE_SCALE_POLICY); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void* jarg1, void* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector3* arg2 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Vector3*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return; + } + { + try + { + (arg1)->SetProperty(Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const&)*arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector3 result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = ((Dali::Actor const*)arg1)->GetProperty(Actor::Property::SIZE_MODE_FACTOR); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3&)result); + return jresult; +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void* jarg1, float jarg2) +{ + float jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + float arg2; + float result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (float)jarg2; + { + try + { + result = (float)(arg1)->GetHeightForWidth(arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void* jarg1, float jarg2) +{ + float jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + float arg2; + float result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (float)jarg2; + { + try + { + result = (float)(arg1)->GetWidthForHeight(arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void* jarg1, int jarg2) +{ + float jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Dimension::Type arg2; + float result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Dimension::Type)jarg2; + { + try + { + result = (float)((Dali::Actor const*)arg1)->GetRelayoutSize(arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void* jarg1, void* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Padding* arg2 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Padding*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0); + return; + } + { + try + { + (arg1)->SetProperty(Actor::Property::PADDING, (Dali::Padding const&)*arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void* jarg1, void* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Padding* arg2 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Padding*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0); + return; + } + { + try + { + *arg2 = ((Dali::Actor const*)arg1)->GetProperty(Actor::Property::PADDING); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void* jarg1, void* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector2* arg2 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Vector2*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return; + } + { + try + { + (arg1)->SetProperty(Actor::Property::MINIMUM_SIZE, (Dali::Vector2 const&)*arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector2 result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (arg1)->GetProperty(Actor::Property::MINIMUM_SIZE); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2&)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void* jarg1, void* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector2* arg2 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Vector2*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return; + } + { + try + { + (arg1)->SetProperty(Actor::Property::MAXIMUM_SIZE, (Dali::Vector2 const&)*arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void* jarg1) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Vector2 result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (arg1)->GetProperty(Actor::Property::MAXIMUM_SIZE); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2&)result); + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void* jarg1) +{ + int jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + int result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (int)(arg1)->GetProperty(Actor::Property::HIERARCHY_DEPTH); + Dali::Actor parent = ((Dali::Actor const*)arg1)->GetParent(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void* jarg1, void* jarg2) +{ + unsigned int jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Renderer* arg2 = 0; + unsigned int result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Renderer*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0); + return 0; + } + { + try + { + result = (unsigned int)(arg1)->AddRenderer(*arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void* jarg1) +{ + unsigned int jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + unsigned int result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + { + try + { + result = (unsigned int)((Dali::Actor const*)arg1)->GetRendererCount(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void* jarg1, unsigned int jarg2) +{ + void* jresult; + Dali::Actor* arg1 = (Dali::Actor*)0; + unsigned int arg2; + Dali::Renderer result; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return 0; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (unsigned int)jarg2; + { + try + { + result = (arg1)->GetRendererAt(arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Renderer((const Dali::Renderer&)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void* jarg1, void* jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + Dali::Renderer* arg2 = 0; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (Dali::Renderer*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0); + return; + } + { + try + { + (arg1)->RemoveRenderer(*arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void* jarg1, unsigned int jarg2) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + unsigned int arg2; + + if(!jarg1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); + return; + } + + arg1 = (Dali::Actor*)jarg1; + arg2 = (unsigned int)jarg2; + { + try + { + (arg1)->RemoveRenderer(arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetNeedGesturePropagation(void* jarg1, bool jarg2) +{ + Dali::Actor arg1; + bool arg2; + Dali::Actor* argp1 = (Dali::Actor*)0; + + argp1 = (Dali::Actor*)jarg1; + if(!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return; + } + arg1 = *argp1; + arg2 = jarg2; + { + try + { + Dali::DevelActor::SetNeedGesturePropagation(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_CalculateScreenPosition(void* actor) +{ + void* jresult; + Dali::Actor arg1; + Dali::Actor* argp1 = (Dali::Actor*)0; + Dali::Vector2 result; + + argp1 = (Dali::Actor*)actor; + if(!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg1 = *argp1; + { + try + { + result = Dali::DevelActor::CalculateScreenPosition(arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_CalculateScreenExtents(void* actor) +{ + Dali::Actor arg1; + Dali::Actor* argp1 = (Dali::Actor*)0; + Dali::Rect result; + + argp1 = (Dali::Actor*)actor; + if(!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg1 = *argp1; + { + try + { + result = Dali::DevelActor::CalculateScreenExtents(arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + // Note: The float type Rectangle class is not ready yet. + // Therefore, it transmits data in Vector4 class. + // This type should later be changed to the appropriate data type. + return new Dali::Vector4(result.x, result.y, result.width, result.height); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_CurrentScreenExtents(void* actor) +{ + Dali::Actor arg1; + Dali::Actor* argp1 = (Dali::Actor*)0; + Dali::Rect result; + + argp1 = (Dali::Actor*)actor; + if(!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg1 = *argp1; + { + try + { + result = Dali::DevelActor::CalculateCurrentScreenExtents(arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + // Note: The float type Rectangle class is not ready yet. + // Therefore, it transmits data in Vector4 class. + // This type should later be changed to the appropriate data type. + return new Dali::Vector4(result.x, result.y, result.width, result.height); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_LookAt(void* csActor, void* csTarget, void* csUp, void* csLocalForward, void* csLocalUp) +{ + Dali::Actor actor; + Dali::Vector3 target; + Dali::Vector3 up = Vector3::YAXIS; + Dali::Vector3 localForward = Vector3::ZAXIS; + Dali::Vector3 localUp = Vector3::YAXIS; + + if(!csActor) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return; + } + + if(!csTarget) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null target Dali::Vector3", 0); + return; + } + + actor = *(Dali::Actor*)csActor; + target = *(Dali::Vector3*)csTarget; + + // Use default value if csUp is null + if(csUp) + { + up = *(Dali::Vector3*)csUp; + } + + // Use default value if csLocalForward is null + if(csLocalForward) + { + localForward = *(Dali::Vector3*)csLocalForward; + } + + // Use default value if csLocalForward is null + if(csLocalUp) + { + localUp = *(Dali::Vector3*)csLocalUp; + } + + { + try + { + Dali::DevelActor::LookAt(actor, target, up, localForward, localUp); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_SetTouchAreaOffset(void* jarg1, int jarg2, int jarg3, int jarg4, int jarg5) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + arg1 = (Dali::Actor*)jarg1; + Rect arg2 = Rect(jarg2, jarg3, jarg4, jarg5); + { + try + { + (arg1)->SetProperty(Dali::DevelActor::Property::TOUCH_AREA_OFFSET, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_GetTouchAreaOffset(void* jarg1, int* jarg2, int* jarg3, int* jarg4, int* jarg5) +{ + Dali::Actor* arg1 = (Dali::Actor*)0; + arg1 = (Dali::Actor*)jarg1; + + Rect result; + { + try + { + result = (arg1)->GetProperty>(Dali::DevelActor::Property::TOUCH_AREA_OFFSET); + *jarg2 = result.left; + *jarg3 = result.right; + *jarg4 = result.bottom; + *jarg5 = result.top; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void* jarg1) +{ + Dali::Actor* arg1 = 0; + + arg1 = (Dali::Actor*)jarg1; + if(!arg1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); + return; + } + { + try + { + Dali::UnparentAndReset(*arg1); + } + CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetSuggestedMinimumWidth(void * jarg1) { + Dali::Actor *arg1 = (Dali::Actor *) 0; + Dali::Vector2 maximumSize; + Dali::Vector2 minimumSize; + Dali::Vector3 naturalSize; + bool widthForHeight; + float result; + { + try { + arg1 = (Dali::Actor *)jarg1; + maximumSize = arg1->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE ); + minimumSize = arg1->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE ); + naturalSize = arg1->GetNaturalSize(); + widthForHeight = arg1->GetProperty< bool >( Actor::Property::WIDTH_FOR_HEIGHT ); + + float baseWidth; + if (widthForHeight) + { + float baseHeight = maximumSize.height > 0 ? std::min(maximumSize.height, naturalSize.height) : naturalSize.height; + baseWidth = arg1->GetWidthForHeight(baseHeight); + } + else + { + baseWidth = naturalSize.width; + } + + result = minimumSize.width > 0 ? std::max(baseWidth, minimumSize.width) : baseWidth; + result = maximumSize.width > 0 ? std::min(result, maximumSize.width) : result; + } CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetSuggestedMinimumHeight(void * jarg1) { + Dali::Actor *arg1 = (Dali::Actor *) 0; + Dali::Vector2 maximumSize; + Dali::Vector2 minimumSize; + Dali::Vector3 naturalSize; + bool heightForWidth; + float result; + { + try { + arg1 = (Dali::Actor *)jarg1; + maximumSize = arg1->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE ); + minimumSize = arg1->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE ); + naturalSize = arg1->GetNaturalSize(); + heightForWidth = arg1->GetProperty< bool >( Actor::Property::HEIGHT_FOR_WIDTH ); + + float baseHeight; + if (heightForWidth) + { + float baseWidth = maximumSize.width > 0 ? std::min(maximumSize.width, naturalSize.width) : naturalSize.width; + baseHeight = arg1->GetHeightForWidth(baseWidth); + } + else + { + baseHeight = naturalSize.height; + } + + result = minimumSize.height > 0 ? std::max(baseHeight, minimumSize.height) : baseHeight; + result = maximumSize.height > 0 ? std::min(result, maximumSize.height) : result; + } CALL_CATCH_EXCEPTION(0); + } + + return result; +} + + +// Signals +#ifndef GENERATE_DEVEL_ACTOR_SIGNAL +#define GENERATE_DEVEL_ACTOR_SIGNAL(HType, SignalName) GENERATE_DEVEL_SIGNAL(Dali::Actor*, HType, Dali::DevelActor, Dali_Actor, SignalName) +#endif +#ifndef GENERATE_ACTOR_SIGNAL +#define GENERATE_ACTOR_SIGNAL(HType, SignalName) GENERATE_SIGNAL(Dali::Actor*, HType, Dali_Actor, SignalName) +#endif + +GENERATE_DEVEL_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::TouchEvent const&), HitTestResultSignal) +// CSharp_Dali_Actor_HitTestResultSignal_Connect +// CSharp_Dali_Actor_HitTestResultSignal_Disconnect + +GENERATE_DEVEL_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::TouchEvent const&), InterceptTouchedSignal) +// CSharp_Dali_Actor_InterceptTouchedSignal_Connect +// CSharp_Dali_Actor_InterceptTouchedSignal_Disconnect + +GENERATE_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::TouchEvent const&), TouchedSignal) +// CSharp_Dali_Actor_TouchedSignal_Connect +// CSharp_Dali_Actor_TouchedSignal_Disconnect + +GENERATE_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::HoverEvent const&), HoveredSignal) +// CSharp_Dali_Actor_HoveredSignal_Connect +// CSharp_Dali_Actor_HoveredSignal_Disconnect + +GENERATE_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::WheelEvent const&), WheelEventSignal) +// CSharp_Dali_Actor_WheelEventSignal_Connect +// CSharp_Dali_Actor_WheelEventSignal_Disconnect + +GENERATE_DEVEL_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::WheelEvent const&), InterceptWheelSignal) +// CSharp_Dali_Actor_InterceptWheelSignal_Connect +// CSharp_Dali_Actor_InterceptWheelSignal_Disconnect + +GENERATE_ACTOR_SIGNAL(void(*)(Dali::Actor), OnSceneSignal) +// CSharp_Dali_Actor_OnSceneSignal_Connect +// CSharp_Dali_Actor_OnSceneSignal_Disconnect + +GENERATE_ACTOR_SIGNAL(void(*)(Dali::Actor), OffSceneSignal) +// CSharp_Dali_Actor_OffSceneSignal_Connect +// CSharp_Dali_Actor_OffSceneSignal_Disconnect + +GENERATE_ACTOR_SIGNAL(void(*)(Dali::Actor), OnRelayoutSignal) +// CSharp_Dali_Actor_OnRelayoutSignal_Connect +// CSharp_Dali_Actor_OnRelayoutSignal_Disconnect + +GENERATE_DEVEL_ACTOR_SIGNAL(void(*)(Dali::Actor, bool, Dali::DevelActor::VisibilityChange::Type), VisibilityChangedSignal) +// CSharp_Dali_Actor_VisibilityChangedSignal_Connect +// CSharp_Dali_Actor_VisibilityChangedSignal_Disconnect + +GENERATE_ACTOR_SIGNAL(void(*)(Dali::Actor, LayoutDirection::Type), LayoutDirectionChangedSignal) +// CSharp_Dali_Actor_LayoutDirectionChangedSignal_Connect +// CSharp_Dali_Actor_LayoutDirectionChangedSignal_Disconnect + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-core/animation-wrap.cpp b/dali-csharp-binder/dali-core/animation-wrap.cpp new file mode 100755 index 00000000..e8730f3c --- /dev/null +++ b/dali-csharp-binder/dali-core/animation-wrap.cpp @@ -0,0 +1,1613 @@ +/* + * Copyright (c) 2017 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// EXTERNAL INCLUDES +#include +#include + +// INTERNAL INCLUDES +#include + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){ +return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){ + self->Emit( arg ); +} + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() { + void * jresult ; + Dali::Animation *result = 0 ; + + { + try { + result = (Dali::Animation *)new Dali::Animation(); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) { + void * jresult ; + float arg1 ; + Dali::Animation result; + + arg1 = (float)jarg1; + { + try { + result = Dali::Animation::New(arg1); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = new Dali::Animation((const Dali::Animation &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Animation 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::Animation::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = new Dali::Animation((const Dali::Animation &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + + arg1 = (Dali::Animation *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Animation *arg1 = 0 ; + Dali::Animation *result = 0 ; + + arg1 = (Dali::Animation *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + Dali::Animation *arg2 = 0 ; + Dali::Animation *result = 0 ; + + arg1 = (Dali::Animation *)jarg1; + arg2 = (Dali::Animation *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + float arg2 ; + + arg1 = (Dali::Animation *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetDuration(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) { + float jresult ; + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + float result; + + arg1 = (Dali::Animation *)jarg1; + { + try { + result = (float)((Dali::Animation const *)arg1)->GetDuration(); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + bool arg2 ; + + arg1 = (Dali::Animation *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->SetLooping(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + int arg2 ; + + arg1 = (Dali::Animation *)jarg1; + arg2 = (int)jarg2; + { + try { + (arg1)->SetLoopCount(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) { + int jresult ; + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + int result; + + arg1 = (Dali::Animation *)jarg1; + { + try { + result = (int)(arg1)->GetLoopCount(); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) { + int jresult ; + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + int result; + + arg1 = (Dali::Animation *)jarg1; + { + try { + result = (int)(arg1)->GetCurrentLoop(); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) { + unsigned int jresult ; + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + bool result; + + arg1 = (Dali::Animation *)jarg1; + { + try { + result = (bool)((Dali::Animation const *)arg1)->IsLooping(); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + Dali::Animation::EndAction arg2 ; + + arg1 = (Dali::Animation *)jarg1; + arg2 = (Dali::Animation::EndAction)jarg2; + { + try { + (arg1)->SetEndAction(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) { + int jresult ; + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + Dali::Animation::EndAction result; + + arg1 = (Dali::Animation *)jarg1; + { + try { + result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction(); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + Dali::Animation::EndAction arg2 ; + + arg1 = (Dali::Animation *)jarg1; + arg2 = (Dali::Animation::EndAction)jarg2; + { + try { + (arg1)->SetDisconnectAction(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) { + int jresult ; + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + Dali::Animation::EndAction result; + + arg1 = (Dali::Animation *)jarg1; + { + try { + result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction(); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + Dali::AlphaFunction arg2 ; + Dali::AlphaFunction *argp2 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::AlphaFunction *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetDefaultAlphaFunction(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) { + void * jresult ; + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + Dali::AlphaFunction result; + + arg1 = (Dali::Animation *)jarg1; + { + try { + result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction(); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + float arg2 ; + + arg1 = (Dali::Animation *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetCurrentProgress(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) { + float jresult ; + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + float result; + + arg1 = (Dali::Animation *)jarg1; + { + try { + result = (float)(arg1)->GetCurrentProgress(); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + float arg2 ; + + arg1 = (Dali::Animation *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetSpeedFactor(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) { + float jresult ; + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + float result; + + arg1 = (Dali::Animation *)jarg1; + { + try { + result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor(); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + Dali::Vector2 *arg2 = 0 ; + + arg1 = (Dali::Animation *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) { + void * jresult ; + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::Animation *)jarg1; + { + try { + result = ((Dali::Animation const *)arg1)->GetPlayRange(); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + + arg1 = (Dali::Animation *)jarg1; + { + try { + (arg1)->Play(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + float arg2 ; + + arg1 = (Dali::Animation *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->PlayFrom(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + + arg1 = (Dali::Animation *)jarg1; + { + try { + (arg1)->Pause(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) { + int jresult ; + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + Dali::Animation::State result; + + arg1 = (Dali::Animation *)jarg1; + { + try { + result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState(); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + + arg1 = (Dali::Animation *)jarg1; + { + try { + (arg1)->Stop(); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetProgressNotification(void* jarg1, float jarg2) { + Dali::Animation* argp1 = (Dali::Animation *) jarg1 ; + + Dali::Animation arg1 = *argp1; + float arg2 = (float)jarg2; + + { + try { + Dali::DevelAnimation::SetProgressNotification(arg1, arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetProgressNotification(void * jarg1) { + float jresult ; + Dali::Animation* argp1 = (Dali::Animation *) jarg1 ; + float result; + + Dali::Animation arg1 = *argp1; + { + try { + result = (float)Dali::DevelAnimation::GetProgressNotification(arg1); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetBlendPoint(void* csAnimation, float blendPoint) { + Dali::Animation* animation = (Dali::Animation *) csAnimation ; + + { + try { + animation->SetBlendPoint(blendPoint); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetBlendPoint(void * csAnimation) { + Dali::Animation* animation = (Dali::Animation *) csAnimation ; + float result; + + { + try { + result = animation->GetBlendPoint(); + } CALL_CATCH_EXCEPTION(0); + + } + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + + arg1 = (Dali::Animation *)jarg1; + { + try { + (arg1)->Clear(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopingMode(void * jarg1, int jarg2) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + Dali::Animation::LoopingMode arg2 ; + + arg1 = (Dali::Animation *)jarg1; + arg2 = (Dali::Animation::LoopingMode)jarg2; + { + try { + (arg1)->SetLoopingMode(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopingMode(void * jarg1) { + int jresult ; + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + Dali::Animation::LoopingMode result; + + arg1 = (Dali::Animation *)jarg1; + { + try { + result = (Dali::Animation::LoopingMode)((Dali::Animation const *)arg1)->GetLoopingMode(); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) { + void * jresult ; + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + Dali::Animation::AnimationSignalType *result = 0 ; + + arg1 = (Dali::Animation *)jarg1; + { + try { + result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal(); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_ProgressReachedSignal(void * jarg1) { + void * jresult ; + Dali::Animation* argp1 = (Dali::Animation*) jarg1 ; + Dali::Animation::AnimationSignalType *result = 0 ; + + Dali::Animation arg1 = *argp1; + { + try { + result = (Dali::Animation::AnimationSignalType* ) &Dali::DevelAnimation::ProgressReachedSignal(arg1); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayAfter(void * jarg1, float jarg2) { + Dali::Animation arg1 ; + float arg2 ; + Dali::Animation *argp1 ; + + argp1 = (Dali::Animation *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Animation", 0); + return ; + } + arg1 = *argp1; + arg2 = (float)jarg2; + { + try { + arg1.PlayAfter(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + Dali::Property::Value arg3 ; + Dali::Property *argp2 ; + Dali::Property::Value *argp3 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Property::Value *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); + return ; + } + arg3 = *argp3; + { + try { + (arg1)->AnimateBy(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + Dali::Property::Value arg3 ; + Dali::AlphaFunction arg4 ; + Dali::Property *argp2 ; + Dali::Property::Value *argp3 ; + Dali::AlphaFunction *argp4 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Property::Value *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); + return ; + } + arg3 = *argp3; + argp4 = (Dali::AlphaFunction *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); + return ; + } + arg4 = *argp4; + { + try { + (arg1)->AnimateBy(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + Dali::Property::Value arg3 ; + SwigValueWrapper< Dali::TimePeriod > arg4 ; + Dali::Property *argp2 ; + Dali::Property::Value *argp3 ; + Dali::TimePeriod *argp4 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Property::Value *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); + return ; + } + arg3 = *argp3; + argp4 = (Dali::TimePeriod *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); + return ; + } + arg4 = *argp4; + { + try { + (arg1)->AnimateBy(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + Dali::Property::Value arg3 ; + Dali::AlphaFunction arg4 ; + SwigValueWrapper< Dali::TimePeriod > arg5 ; + Dali::Property *argp2 ; + Dali::Property::Value *argp3 ; + Dali::AlphaFunction *argp4 ; + Dali::TimePeriod *argp5 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Property::Value *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); + return ; + } + arg3 = *argp3; + argp4 = (Dali::AlphaFunction *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); + return ; + } + arg4 = *argp4; + argp5 = (Dali::TimePeriod *)jarg5; + if (!argp5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); + return ; + } + arg5 = *argp5; + { + try { + (arg1)->AnimateBy(arg2,arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + Dali::Property::Value arg3 ; + Dali::Property *argp2 ; + Dali::Property::Value *argp3 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Property::Value *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); + return ; + } + arg3 = *argp3; + { + try { + (arg1)->AnimateTo(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + Dali::Property::Value arg3 ; + Dali::AlphaFunction arg4 ; + Dali::Property *argp2 ; + Dali::Property::Value *argp3 ; + Dali::AlphaFunction *argp4 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Property::Value *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); + return ; + } + arg3 = *argp3; + argp4 = (Dali::AlphaFunction *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); + return ; + } + arg4 = *argp4; + { + try { + (arg1)->AnimateTo(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + Dali::Property::Value arg3 ; + SwigValueWrapper< Dali::TimePeriod > arg4 ; + Dali::Property *argp2 ; + Dali::Property::Value *argp3 ; + Dali::TimePeriod *argp4 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Property::Value *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); + return ; + } + arg3 = *argp3; + argp4 = (Dali::TimePeriod *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); + return ; + } + arg4 = *argp4; + { + try { + (arg1)->AnimateTo(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + Dali::Property::Value arg3 ; + Dali::AlphaFunction arg4 ; + SwigValueWrapper< Dali::TimePeriod > arg5 ; + Dali::Property *argp2 ; + Dali::Property::Value *argp3 ; + Dali::AlphaFunction *argp4 ; + Dali::TimePeriod *argp5 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Property::Value *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); + return ; + } + arg3 = *argp3; + argp4 = (Dali::AlphaFunction *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); + return ; + } + arg4 = *argp4; + argp5 = (Dali::TimePeriod *)jarg5; + if (!argp5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); + return ; + } + arg5 = *argp5; + { + try { + (arg1)->AnimateTo(arg2,arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + Dali::KeyFrames *arg3 = 0 ; + Dali::Property *argp2 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::KeyFrames *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0); + return ; + } + { + try { + (arg1)->AnimateBetween(arg2,*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + Dali::KeyFrames *arg3 = 0 ; + Dali::Animation::Interpolation arg4 ; + Dali::Property *argp2 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::KeyFrames *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0); + return ; + } + arg4 = (Dali::Animation::Interpolation)jarg4; + { + try { + (arg1)->AnimateBetween(arg2,*arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + Dali::KeyFrames *arg3 = 0 ; + Dali::AlphaFunction arg4 ; + Dali::Property *argp2 ; + Dali::AlphaFunction *argp4 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::KeyFrames *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0); + return ; + } + argp4 = (Dali::AlphaFunction *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); + return ; + } + arg4 = *argp4; + { + try { + (arg1)->AnimateBetween(arg2,*arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + Dali::KeyFrames *arg3 = 0 ; + Dali::AlphaFunction arg4 ; + Dali::Animation::Interpolation arg5 ; + Dali::Property *argp2 ; + Dali::AlphaFunction *argp4 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::KeyFrames *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0); + return ; + } + argp4 = (Dali::AlphaFunction *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); + return ; + } + arg4 = *argp4; + arg5 = (Dali::Animation::Interpolation)jarg5; + { + try { + (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + Dali::KeyFrames *arg3 = 0 ; + SwigValueWrapper< Dali::TimePeriod > arg4 ; + Dali::Property *argp2 ; + Dali::TimePeriod *argp4 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::KeyFrames *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0); + return ; + } + argp4 = (Dali::TimePeriod *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); + return ; + } + arg4 = *argp4; + { + try { + (arg1)->AnimateBetween(arg2,*arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + Dali::KeyFrames *arg3 = 0 ; + SwigValueWrapper< Dali::TimePeriod > arg4 ; + Dali::Animation::Interpolation arg5 ; + Dali::Property *argp2 ; + Dali::TimePeriod *argp4 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::KeyFrames *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0); + return ; + } + argp4 = (Dali::TimePeriod *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); + return ; + } + arg4 = *argp4; + arg5 = (Dali::Animation::Interpolation)jarg5; + { + try { + (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + Dali::KeyFrames *arg3 = 0 ; + Dali::AlphaFunction arg4 ; + SwigValueWrapper< Dali::TimePeriod > arg5 ; + Dali::Property *argp2 ; + Dali::AlphaFunction *argp4 ; + Dali::TimePeriod *argp5 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::KeyFrames *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0); + return ; + } + argp4 = (Dali::AlphaFunction *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); + return ; + } + arg4 = *argp4; + argp5 = (Dali::TimePeriod *)jarg5; + if (!argp5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); + return ; + } + arg5 = *argp5; + { + try { + (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + SwigValueWrapper< Dali::Property > arg2 ; + Dali::KeyFrames *arg3 = 0 ; + Dali::AlphaFunction arg4 ; + SwigValueWrapper< Dali::TimePeriod > arg5 ; + Dali::Animation::Interpolation arg6 ; + Dali::Property *argp2 ; + Dali::AlphaFunction *argp4 ; + Dali::TimePeriod *argp5 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Property *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::KeyFrames *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0); + return ; + } + argp4 = (Dali::AlphaFunction *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); + return ; + } + arg4 = *argp4; + argp5 = (Dali::TimePeriod *)jarg5; + if (!argp5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); + return ; + } + arg5 = *argp5; + arg6 = (Dali::Animation::Interpolation)jarg6; + { + try { + (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + Dali::Actor arg2 ; + Dali::Path arg3 ; + Dali::Vector3 *arg4 = 0 ; + Dali::Actor *argp2 ; + Dali::Path *argp3 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Path *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0); + return ; + } + arg3 = *argp3; + arg4 = (Dali::Vector3 *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + { + try { + (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + Dali::Actor arg2 ; + Dali::Path arg3 ; + Dali::Vector3 *arg4 = 0 ; + Dali::AlphaFunction arg5 ; + Dali::Actor *argp2 ; + Dali::Path *argp3 ; + Dali::AlphaFunction *argp5 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Path *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0); + return ; + } + arg3 = *argp3; + arg4 = (Dali::Vector3 *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + argp5 = (Dali::AlphaFunction *)jarg5; + if (!argp5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); + return ; + } + arg5 = *argp5; + { + try { + (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + Dali::Actor arg2 ; + Dali::Path arg3 ; + Dali::Vector3 *arg4 = 0 ; + SwigValueWrapper< Dali::TimePeriod > arg5 ; + Dali::Actor *argp2 ; + Dali::Path *argp3 ; + Dali::TimePeriod *argp5 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Path *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0); + return ; + } + arg3 = *argp3; + arg4 = (Dali::Vector3 *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + argp5 = (Dali::TimePeriod *)jarg5; + if (!argp5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); + return ; + } + arg5 = *argp5; + { + try { + (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + Dali::Actor arg2 ; + Dali::Path arg3 ; + Dali::Vector3 *arg4 = 0 ; + Dali::AlphaFunction arg5 ; + SwigValueWrapper< Dali::TimePeriod > arg6 ; + Dali::Actor *argp2 ; + Dali::Path *argp3 ; + Dali::AlphaFunction *argp5 ; + Dali::TimePeriod *argp6 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Path *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0); + return ; + } + arg3 = *argp3; + arg4 = (Dali::Vector3 *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + argp5 = (Dali::AlphaFunction *)jarg5; + if (!argp5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); + return ; + } + arg5 = *argp5; + argp6 = (Dali::TimePeriod *)jarg6; + if (!argp6) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); + return ; + } + arg6 = *argp6; + { + try { + (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + Dali::Actor arg2 ; + float arg3 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + arg3 = (float)jarg3; + { + try { + (arg1)->Show(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) { + Dali::Animation *arg1 = (Dali::Animation *) 0 ; + Dali::Actor arg2 ; + float arg3 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Animation *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + arg3 = (float)jarg3; + { + try { + (arg1)->Hide(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ; + void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1; + arg2 = (void (*)(Dali::Animation &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ; + void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1; + arg2 = (void (*)(Dali::Animation &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ; + Dali::Animation *arg2 = 0 ; + + arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1; + arg2 = (Dali::Animation *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0); + return ; + } + { + try { + Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() { + void * jresult ; + Dali::Signal< void (Dali::Animation &) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >(); + } CALL_CATCH_EXCEPTION(0); + + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) { + Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/dali-core/capabilities-wrap.cpp b/dali-csharp-binder/dali-core/capabilities-wrap.cpp new file mode 100644 index 00000000..7609c636 --- /dev/null +++ b/dali-csharp-binder/dali-core/capabilities-wrap.cpp @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2020 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsBlendEquationSupported( int blendEquation ) { + bool jresult; + + { + try { + jresult = Dali::Capabilities::IsBlendEquationSupported( static_cast(blendEquation) ); + } + CALL_CATCH_EXCEPTION(0); + } + return jresult; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-core/constraint-wrap.cpp b/dali-csharp-binder/dali-core/constraint-wrap.cpp new file mode 100755 index 00000000..a62bd642 --- /dev/null +++ b/dali-csharp-binder/dali-core/constraint-wrap.cpp @@ -0,0 +1,342 @@ +/* + * Copyright (c) 2021 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EqualConstraintWithParentFloat_New(void * nuiHandle, int nuiTargetIndex, int nuiParentIndex) +{ + Dali::Handle *handle = (Dali::Handle *) 0; + Dali::Property::Index targetIndex; + Dali::Property::Index parentIndex; + Dali::Constraint result; + void * jresult = 0; + + handle = (Dali::Handle *)nuiHandle; + if (!handle) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & const is null", 0); + return 0; + } + targetIndex = (Dali::Property::Index)nuiTargetIndex; + parentIndex = (Dali::Property::Index)nuiParentIndex; + + { + try + { + result = Dali::Constraint::New(*handle, targetIndex, Dali::EqualToConstraint()); + result.AddSource(Dali::ParentSource(parentIndex)); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Constraint((const Dali::Constraint &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RelativeConstraintWithParentFloat_New(void * nuiHandle, int nuiTargetIndex, int nuiParentIndex, float nuiRelativeRate) +{ + Dali::Handle *handle = (Dali::Handle *) 0; + Dali::Property::Index targetIndex; + Dali::Property::Index parentIndex; + float relativeRate; + Dali::Constraint result; + void * jresult = 0; + + handle = (Dali::Handle *)nuiHandle; + if (!handle) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & const is null", 0); + return 0; + } + targetIndex = (Dali::Property::Index)nuiTargetIndex; + parentIndex = (Dali::Property::Index)nuiParentIndex; + relativeRate = nuiRelativeRate; + + { + try + { + result = Dali::Constraint::New(*handle, targetIndex, Dali::RelativeToConstraintFloat(relativeRate)); + result.AddSource(Dali::ParentSource(parentIndex)); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Constraint((const Dali::Constraint &)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Constraint_Apply(void * nuiConstraint) +{ + Dali::Constraint *constraint = (Dali::Constraint *) 0; + + constraint = (Dali::Constraint *)nuiConstraint; + if (!constraint) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Constraint is null", 0); + return; + } + + { + try + { + (*constraint).Apply(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Constraint_Remove(void * nuiConstraint) +{ + Dali::Constraint *constraint = (Dali::Constraint *) 0; + + constraint = (Dali::Constraint *)nuiConstraint; + if (!constraint) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Constraint is null", 0); + return; + } + + { + try + { + (*constraint).Remove(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Constraint_REMOVE_ACTION_BAKE_get() +{ + int jresult = 0; + + { + try + { + jresult = (int)Dali::Constraint::BAKE; + } CALL_CATCH_EXCEPTION(0); + } + + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Constraint_REMOVE_ACTION_DISCARD_get() +{ + int jresult = 0; + + { + try + { + jresult = (int)Dali::Constraint::DISCARD; + } CALL_CATCH_EXCEPTION(0); + } + + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Constraint_DEFAULT_REMOVE_ACTION_get() +{ + int jresult = 0; + + { + try + { + jresult = (int)Dali::Constraint::DEFAULT_REMOVE_ACTION; + } CALL_CATCH_EXCEPTION(0); + } + + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Constraint_SetRemoveAction(void * nuiConstraint, int nuiRemoveAction) +{ + Dali::Constraint *constraint = (Dali::Constraint *) 0; + Dali::Constraint::RemoveAction removeAction = Dali::Constraint::DEFAULT_REMOVE_ACTION; + + constraint = (Dali::Constraint *)nuiConstraint; + if (!constraint) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Constraint is null", 0); + return; + } + removeAction = (Dali::Constraint::RemoveAction)nuiRemoveAction; + + { + try + { + (*constraint).SetRemoveAction(removeAction); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Constraint_GetRemoveAction(void * nuiConstraint) +{ + Dali::Constraint *constraint = (Dali::Constraint *) 0; + int jresult = 0; + + constraint = (Dali::Constraint *)nuiConstraint; + if (!constraint) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Constraint is null", 0); + return 0; + } + + { + try + { + jresult = (int)(*constraint).GetRemoveAction(); + } CALL_CATCH_EXCEPTION(0); + } + + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Constraint_SetTag(void * nuiConstraint, unsigned int nuiTag) +{ + Dali::Constraint *constraint = (Dali::Constraint *) 0; + uint32_t tag = 0; + + constraint = (Dali::Constraint *)nuiConstraint; + if (!constraint) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Constraint is null", 0); + return; + } + tag = nuiTag; + + { + try + { + (*constraint).SetTag(tag); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Constraint_GetTag(void * nuiConstraint) +{ + Dali::Constraint *constraint = (Dali::Constraint *) 0; + uint32_t jresult = 0; + + constraint = (Dali::Constraint *)nuiConstraint; + if (!constraint) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Constraint is null", 0); + return 0; + } + + { + try + { + jresult = (*constraint).GetTag(); + } CALL_CATCH_EXCEPTION(0); + } + + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Constraint_GetTargetObject(void * nuiConstraint) +{ + Dali::Constraint *constraint = (Dali::Constraint *) 0; + Dali::Handle result = Dali::Handle(); + void * jresult = 0; + + constraint = (Dali::Constraint *)nuiConstraint; + if (!constraint) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Constraint is null", 0); + return 0; + } + + { + try + { + result = (*constraint).GetTargetObject(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Handle((const Dali::Handle &)result); + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Constraint_GetTargetProperty(void * nuiConstraint) +{ + Dali::Constraint *constraint = (Dali::Constraint *) 0; + Dali::Property::Index result = Dali::Property::INVALID_INDEX; + int jresult = 0; + + constraint = (Dali::Constraint *)nuiConstraint; + if (!constraint) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Constraint is null", 0); + return 0; + } + + { + try + { + result = (*constraint).GetTargetProperty(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Constraint(void * nuiConstraint) +{ + Dali::Constraint *constraint = (Dali::Constraint *) 0; + Dali::Constraint *result; + void * jresult; + + constraint = (Dali::Constraint *)nuiConstraint; + if (!constraint) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Constraint is null", 0); + return 0; + } + + { + try + { + result = new Dali::Constraint(*constraint); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Constraint(void * nuiConstraint) +{ + Dali::Constraint *constraint = (Dali::Constraint *) 0; + + constraint = (Dali::Constraint *)nuiConstraint; + { + try + { + delete constraint; + } CALL_CATCH_EXCEPTION(); + } +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-core/dali-core-wrap.cpp b/dali-csharp-binder/dali-core/dali-core-wrap.cpp new file mode 100644 index 00000000..f9a64d18 --- /dev/null +++ b/dali-csharp-binder/dali-core/dali-core-wrap.cpp @@ -0,0 +1,2801 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include + +// INTERNAL INCLUDES +#include + +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +// SWIGINTERN - the relevant parts of the generated code can be seen the below. + + +using namespace Dali; + +#ifdef __cplusplus +extern "C" { +#endif + + +/* Property */ + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() { + int jresult ; + int result; + + result = (int)(int)Dali::Property::INVALID_INDEX; + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() { + int jresult ; + int result; + + result = (int)(int)Dali::Property::INVALID_KEY; + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() { + int jresult ; + int result; + + result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX; + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() { + int jresult ; + Dali::Property::Index result; + + result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT; + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() { + float jresult ; + float result; + + result = (float)(float)Dali::ParentOrigin::TOP; + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() { + float jresult ; + float result; + + result = (float)(float)Dali::ParentOrigin::BOTTOM; + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() { + float jresult ; + float result; + + result = (float)(float)Dali::ParentOrigin::LEFT; + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() { + float jresult ; + float result; + + result = (float)(float)Dali::ParentOrigin::RIGHT; + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() { + float jresult ; + float result; + + result = (float)(float)Dali::ParentOrigin::MIDDLE; + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() { + float jresult ; + float result; + + result = (float)(float)Dali::AnchorPoint::TOP; + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() { + float jresult ; + float result; + + result = (float)(float)Dali::AnchorPoint::BOTTOM; + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() { + float jresult ; + float result; + + result = (float)(float)Dali::AnchorPoint::LEFT; + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() { + float jresult ; + float result; + + result = (float)(float)Dali::AnchorPoint::RIGHT; + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() { + float jresult ; + float result; + + result = (float)(float)Dali::AnchorPoint::MIDDLE; + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ALICE_BLUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::ALICE_BLUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANTIQUE_WHITE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::ANTIQUE_WHITE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AQUA_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::AQUA; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AQUA_MARINE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::AQUA_MARINE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AZURE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::AZURE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BEIGE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::BEIGE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BISQUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::BISQUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::BLACK; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLANCHE_DALMOND_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::BLANCHE_DALMOND; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::BLUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_VIOLET_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::BLUE_VIOLET; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BROWN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::BROWN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BURLY_WOOD_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::BURLY_WOOD; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CADET_BLUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::CADET_BLUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CHARTREUSE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::CHARTREUSE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CHOCOLATE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::CHOCOLATE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORAL_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::CORAL; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORNFLOWER_BLUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::CORNFLOWER_BLUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORNSILK_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::CORNSILK; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CRIMSON_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::CRIMSON; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::CYAN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_BLUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DARK_BLUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_CYAN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DARK_CYAN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GOLDENROD_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DARK_GOLDENROD; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GRAY_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DARK_GRAY; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GREEN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DARK_GREEN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GREY_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DARK_GREY; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_KHAKI_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DARK_KHAKI; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_MAGENTA_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DARK_MAGENTA; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_OLIVE_GREEN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DARK_OLIVE_GREEN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_ORANGE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DARK_ORANGE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_ORCHID_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DARK_ORCHID; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_RED_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DARK_RED; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SALMON_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DARK_SALMON; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SEA_GREEN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DARK_SEA_GREEN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_BLUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_BLUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_GRAY_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_GRAY; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_GREY_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_GREY; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_TURQUOISE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DARK_TURQUOISE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_VIOLET_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DARK_VIOLET; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DEEP_PINK_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DEEP_PINK; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DEEP_SKY_BLUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DEEP_SKY_BLUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DIM_GRAY_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DIM_GRAY; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DIM_GREY_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DIM_GREY; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DODGER_BLUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::DODGER_BLUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FIRE_BRICK_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::FIRE_BRICK; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FLORAL_WHITE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::FLORAL_WHITE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FOREST_GREEN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::FOREST_GREEN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FUCHSIA_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::FUCHSIA; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GAINSBORO_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::GAINSBORO; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GHOST_WHITE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::GHOST_WHITE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GOLD_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::GOLD; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GOLDEN_ROD_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::GOLDEN_ROD; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GRAY_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::GRAY; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::GREEN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_YELLOW_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::GREEN_YELLOW; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREY_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::GREY; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_HONEYDEW_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::HONEYDEW; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_HOT_PINK_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::HOT_PINK; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_INDIANRED_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::INDIANRED; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_INDIGO_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::INDIGO; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_IVORY_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::IVORY; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KHAKI_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::KHAKI; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAVENDER_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LAVENDER; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAVENDER_BLUSH_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LAVENDER_BLUSH; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAWN_GREEN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LAWN_GREEN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LEMON_CHIFFON_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LEMON_CHIFFON; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_BLUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LIGHT_BLUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_CORAL_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LIGHT_CORAL; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_CYAN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LIGHT_CYAN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GOLDEN_ROD_YELLOW_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LIGHT_GOLDEN_ROD_YELLOW; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GRAY_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LIGHT_GRAY; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GREEN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LIGHT_GREEN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GREY_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LIGHT_GREY; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_PINK_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LIGHT_PINK; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SALMON_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LIGHT_SALMON; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SEA_GREEN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LIGHT_SEA_GREEN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SKY_BLUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LIGHT_SKY_BLUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SLATE_GRAY_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LIGHT_SLATE_GRAY; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SLATE_GREY_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LIGHT_SLATE_GREY; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_STEEL_BLUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LIGHT_STEEL_BLUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_YELLOW_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LIGHT_YELLOW; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIME_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LIME; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIME_GREEN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LIME_GREEN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LINEN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::LINEN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::MAGENTA; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAROON_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::MAROON; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_AQUA_MARINE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::MEDIUM_AQUA_MARINE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_BLUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::MEDIUM_BLUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_ORCHID_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::MEDIUM_ORCHID; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_PURPLE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::MEDIUM_PURPLE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SEA_GREEN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SEA_GREEN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SLATE_BLUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SLATE_BLUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SPRING_GREEN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SPRING_GREEN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_TURQUOISE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::MEDIUM_TURQUOISE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_VIOLETRED_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::MEDIUM_VIOLETRED; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MIDNIGHT_BLUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::MIDNIGHT_BLUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MINT_CREAM_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::MINT_CREAM; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MISTY_ROSE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::MISTY_ROSE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MOCCASIN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::MOCCASIN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NAVAJO_WHITE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::NAVAJO_WHITE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NAVY_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::NAVY; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLD_LACE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::OLD_LACE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLIVE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::OLIVE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLIVE_DRAB_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::OLIVE_DRAB; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORANGE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::ORANGE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORANGE_RED_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::ORANGE_RED; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORCHID_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::ORCHID; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_GOLDEN_ROD_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::PALE_GOLDEN_ROD; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_GREEN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::PALE_GREEN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_TURQUOISE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::PALE_TURQUOISE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_VIOLET_RED_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::PALE_VIOLET_RED; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PAPAYA_WHIP_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::PAPAYA_WHIP; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PEACH_PUFF_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::PEACH_PUFF; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PERU_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::PERU; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PINK_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::PINK; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PLUM_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::PLUM; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_POWDER_BLUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::POWDER_BLUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PURPLE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::PURPLE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::RED; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ROSY_BROWN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::ROSY_BROWN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ROYAL_BLUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::ROYAL_BLUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SADDLE_BROWN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::SADDLE_BROWN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SALMON_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::SALMON; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SANDY_BROWN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::SANDY_BROWN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SEA_GREEN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::SEA_GREEN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SEA_SHELL_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::SEA_SHELL; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SIENNA_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::SIENNA; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SILVER_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::SILVER; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SKY_BLUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::SKY_BLUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_BLUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::SLATE_BLUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_GRAY_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::SLATE_GRAY; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_GREY_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::SLATE_GREY; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SNOW_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::SNOW; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SPRING_GREEN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::SPRING_GREEN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_STEEL_BLUE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::STEEL_BLUE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TAN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::TAN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TEAL_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::TEAL; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_THISTLE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::THISTLE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TOMATO_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::TOMATO; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TURQUOISE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::TURQUOISE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VIOLET_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::VIOLET; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHEAT_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::WHEAT; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::WHITE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_SMOKE_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::WHITE_SMOKE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::YELLOW; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_GREEN_get() { + void * jresult; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Color::YELLOW_GREEN; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() { + float jresult ; + float result; + + result = (float)(float)Dali::Math::MACHINE_EPSILON_0; + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() { + float jresult ; + float result; + + result = (float)(float)Dali::Math::MACHINE_EPSILON_1; + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() { + float jresult ; + float result; + + result = (float)(float)Dali::Math::MACHINE_EPSILON_10; + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() { + float jresult ; + float result; + + result = (float)(float)Dali::Math::MACHINE_EPSILON_100; + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() { + float jresult ; + float result; + + result = (float)(float)Dali::Math::MACHINE_EPSILON_1000; + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() { + float jresult ; + float result; + + result = (float)(float)Dali::Math::MACHINE_EPSILON_10000; + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() { + float jresult ; + float result; + + result = (float)(float)Dali::Math::PI; + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() { + float jresult ; + float result; + + result = (float)(float)Dali::Math::PI_2; + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() { + float jresult ; + float result; + + result = (float)(float)Dali::Math::PI_4; + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() { + float jresult ; + float result; + + result = (float)(float)Dali::Math::PI_OVER_180; + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() { + float jresult ; + float result; + + result = (float)(float)Dali::Math::ONE80_OVER_PI; + jresult = result; + return jresult; +} + + + +// Method + +// Any + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() { + void * jresult ; + Dali::Any *result = 0 ; + + { + try { + result = (Dali::Any *)new Dali::Any(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) { + Dali::Any *arg1 = (Dali::Any *) 0 ; + + arg1 = (Dali::Any *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) { + char *arg1 = (char *) 0 ; + + arg1 = (char *)jarg1; + { + try { + Dali::Any::AssertAlways((char const *)arg1); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) { + void * jresult ; + Dali::Any *arg1 = 0 ; + Dali::Any *result = 0 ; + + arg1 = (Dali::Any *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Any *arg1 = (Dali::Any *) 0 ; + Dali::Any *arg2 = 0 ; + Dali::Any *result = 0 ; + + arg1 = (Dali::Any *)jarg1; + arg2 = (Dali::Any *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) { + void * jresult ; + Dali::Any *arg1 = (Dali::Any *) 0 ; + std::type_info *result = 0 ; + + arg1 = (Dali::Any *)jarg1; + { + try { + result = (std::type_info *) &((Dali::Any const *)arg1)->GetType(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) { + bool jresult ; + Dali::Any *arg1 = (Dali::Any *) 0 ; + bool result; + + arg1 = (Dali::Any *)jarg1; + { + try { + result = (bool)((Dali::Any const *)arg1)->Empty(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + + +// Vector + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorVector2_BaseType_get() { + int jresult ; + int result; + + result = (int)Dali::Vector< Dali::Vector2 >::BaseType; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorVector2__SWIG_0() { + void * jresult ; + Dali::Vector< Dali::Vector2 > *result = 0 ; + + { + try { + result = (Dali::Vector< Dali::Vector2 > *)new Dali::Vector< Dali::Vector2 >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorVector2(void * jarg1) { + Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; + + arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorVector2__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Vector< Dali::Vector2 > *arg1 = 0 ; + Dali::Vector< Dali::Vector2 > *result = 0 ; + + arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector< Dali::Vector2 > *)new Dali::Vector< Dali::Vector2 >((Dali::Vector< Dali::Vector2 > const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; + Dali::Vector< Dali::Vector2 > *arg2 = 0 ; + Dali::Vector< Dali::Vector2 > *result = 0 ; + + arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; + arg2 = (Dali::Vector< Dali::Vector2 > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector< Dali::Vector2 > *) &(arg1)->operator =((Dali::Vector< Dali::Vector2 > const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Begin(void * jarg1) { + void * jresult ; + Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; + Dali::Vector< Dali::Vector2 >::Iterator result; + + arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; + { + try { + result = (Dali::Vector< Dali::Vector2 >::Iterator)((Dali::Vector< Dali::Vector2 > const *)arg1)->Begin(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_End(void * jarg1) { + void * jresult ; + Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; + Dali::Vector< Dali::Vector2 >::Iterator result; + + arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; + { + try { + result = (Dali::Vector< Dali::Vector2 >::Iterator)((Dali::Vector< Dali::Vector2 > const *)arg1)->End(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) { + void * jresult ; + Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; + Dali::Vector< Dali::Vector2 >::SizeType arg2 ; + Dali::Vector< Dali::Vector2 >::ItemType *result = 0 ; + + arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; + arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2; + { + try { + result = (Dali::Vector< Dali::Vector2 >::ItemType *) &(arg1)->operator [](arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_PushBack(void * jarg1, void * jarg2) { + Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; + Dali::Vector< Dali::Vector2 >::ItemType *arg2 = 0 ; + + arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; + arg2 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 >::ItemType const & type is null", 0); + return ; + } + { + try { + (arg1)->PushBack((Dali::Vector< Dali::Vector2 >::ItemType const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { + Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; + Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ; + Dali::Vector< Dali::Vector2 >::ItemType *arg3 = 0 ; + + arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; + arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2; + arg3 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 >::ItemType const & type is null", 0); + return ; + } + { + try { + (arg1)->Insert(arg2,(Dali::Vector< Dali::Vector2 >::ItemType const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { + Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; + Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ; + Dali::Vector< Dali::Vector2 >::Iterator arg3 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ; + Dali::Vector< Dali::Vector2 >::Iterator arg4 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ; + + arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; + arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2; + arg3 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg3; + arg4 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg4; + { + try { + (arg1)->Insert(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Reserve(void * jarg1, unsigned long jarg2) { + Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; + Dali::Vector< Dali::Vector2 >::SizeType arg2 ; + + arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; + arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2; + { + try { + (arg1)->Reserve(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Resize__SWIG_0(void * jarg1, unsigned long jarg2) { + Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; + Dali::Vector< Dali::Vector2 >::SizeType arg2 ; + + arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; + arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2; + { + try { + (arg1)->Resize(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) { + Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; + Dali::Vector< Dali::Vector2 >::SizeType arg2 ; + Dali::Vector< Dali::Vector2 >::ItemType *arg3 = 0 ; + + arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; + arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2; + arg3 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0); + return ; + } + { + try { + (arg1)->Resize(arg2,(Dali::Vector< Dali::Vector2 >::ItemType const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Erase__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; + Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ; + Dali::Vector< Dali::Vector2 >::Iterator result; + + arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; + arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2; + { + try { + result = (Dali::Vector< Dali::Vector2 >::Iterator)(arg1)->Erase(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) { + void * jresult ; + Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; + Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ; + Dali::Vector< Dali::Vector2 >::Iterator arg3 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ; + Dali::Vector< Dali::Vector2 >::Iterator result; + + arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; + arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2; + arg3 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg3; + { + try { + result = (Dali::Vector< Dali::Vector2 >::Iterator)(arg1)->Erase(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Remove(void * jarg1, void * jarg2) { + Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; + Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ; + + arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; + arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2; + { + try { + (arg1)->Remove(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Swap(void * jarg1, void * jarg2) { + Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; + Dali::Vector< Dali::Vector2 > *arg2 = 0 ; + + arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; + arg2 = (Dali::Vector< Dali::Vector2 > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > & type is null", 0); + return ; + } + { + try { + (arg1)->Swap(*arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Clear(void * jarg1) { + Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; + + arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; + { + try { + (arg1)->Clear(); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Release(void * jarg1) { + Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; + + arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; + { + try { + (arg1)->Release(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorVector2_Size(void * jarg1) { + Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; + int size; + + arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; + { + try { + size = (arg1)->Size(); + } CALL_CATCH_EXCEPTION(0); + } + + return size; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_BaseType_get() { + int jresult; + int result; + + result = (int)Dali::Vector::BaseType; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_VectorUnsignedInteger__SWIG_0() { + void *jresult; + Dali::Vector *result = 0; + + { + try { + result = (Dali::Vector *)new Dali::Vector(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_delete_VectorUnsignedInteger(void *jarg1) { + Dali::Vector *arg1 = (Dali::Vector *)0; + + arg1 = (Dali::Vector *)jarg1; + { + try { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL +CSharp_Dali_new_VectorUnsignedInteger__SWIG_1(void *jarg1) { + void *jresult; + Dali::Vector *arg1 = 0; + Dali::Vector *result = 0; + + arg1 = (Dali::Vector *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Dali::Vector< uint32_t > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector *)new Dali::Vector( + (Dali::Vector const &)*arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void *SWIGSTDCALL +CSharp_Dali_VectorUnsignedInteger_Assign(void *jarg1, void *jarg2) { + void *jresult; + Dali::Vector *arg1 = (Dali::Vector *)0; + Dali::Vector *arg2 = 0; + Dali::Vector *result = 0; + + arg1 = (Dali::Vector *)jarg1; + arg2 = (Dali::Vector *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Dali::Vector< uint32_t > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector *)&(arg1)->operator=( + (Dali::Vector const &)*arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void *SWIGSTDCALL +CSharp_Dali_VectorUnsignedInteger_Begin(void *jarg1) { + void *jresult; + Dali::Vector *arg1 = (Dali::Vector *)0; + Dali::Vector::Iterator result; + + arg1 = (Dali::Vector *)jarg1; + { + try { + result = (Dali::Vector::Iterator)( + (Dali::Vector const *)arg1) + ->Begin(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void *SWIGSTDCALL +CSharp_Dali_VectorUnsignedInteger_End(void *jarg1) { + void *jresult; + Dali::Vector *arg1 = (Dali::Vector *)0; + Dali::Vector::Iterator result; + + arg1 = (Dali::Vector *)jarg1; + { + try { + result = (Dali::Vector::Iterator)( + (Dali::Vector const *)arg1) + ->End(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void *SWIGSTDCALL +CSharp_Dali_VectorUnsignedInteger_ValueOfIndex__SWIG_0(void *jarg1, + unsigned long jarg2) { + void *jresult; + Dali::Vector *arg1 = (Dali::Vector *)0; + Dali::Vector::SizeType arg2; + Dali::Vector::ItemType *result = 0; + + arg1 = (Dali::Vector *)jarg1; + arg2 = (Dali::Vector::SizeType)jarg2; + { + try { + result = (Dali::Vector::ItemType *)&(arg1)->operator[](arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_VectorUnsignedInteger_PushBack(void *jarg1, uint32_t jarg2) { + Dali::Vector *arg1 = (Dali::Vector *)0; + Dali::Vector::ItemType *arg2 = 0; + Dali::Vector::ItemType temp2; + + arg1 = (Dali::Vector *)jarg1; + temp2 = (Dali::Vector::ItemType)jarg2; + arg2 = &temp2; + { + try { + (arg1)->PushBack((Dali::Vector::ItemType const &)*arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_Insert__SWIG_0( + void *jarg1, uint32_t *jarg2, uint32_t jarg3) { + Dali::Vector *arg1 = (Dali::Vector *)0; + Dali::Vector::Iterator arg2 = (Dali::Vector::Iterator)0; + Dali::Vector::ItemType *arg3 = 0; + Dali::Vector::ItemType temp3; + + arg1 = (Dali::Vector *)jarg1; + arg2 = jarg2; + temp3 = (Dali::Vector::ItemType)jarg3; + arg3 = &temp3; + { + try { + (arg1)->Insert(arg2, (Dali::Vector::ItemType const &)*arg3); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_Insert__SWIG_1( + void *jarg1, uint32_t *jarg2, void *jarg3, void *jarg4) { + Dali::Vector *arg1 = (Dali::Vector *)0; + Dali::Vector::Iterator arg2 = (Dali::Vector::Iterator)0; + Dali::Vector::Iterator arg3 = (Dali::Vector::Iterator)0; + Dali::Vector::Iterator arg4 = (Dali::Vector::Iterator)0; + + arg1 = (Dali::Vector *)jarg1; + arg2 = jarg2; + arg3 = (Dali::Vector::Iterator)jarg3; + arg4 = (Dali::Vector::Iterator)jarg4; + { + try { + (arg1)->Insert(arg2, arg3, arg4); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_VectorUnsignedInteger_Reserve(void *jarg1, unsigned long jarg2) { + Dali::Vector *arg1 = (Dali::Vector *)0; + Dali::Vector::SizeType arg2; + + arg1 = (Dali::Vector *)jarg1; + arg2 = (Dali::Vector::SizeType)jarg2; + { + try { + (arg1)->Reserve(arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_Resize__SWIG_0( + void *jarg1, unsigned long jarg2) { + Dali::Vector *arg1 = (Dali::Vector *)0; + Dali::Vector::SizeType arg2; + + arg1 = (Dali::Vector *)jarg1; + arg2 = (Dali::Vector::SizeType)jarg2; + { + try { + (arg1)->Resize(arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_Resize__SWIG_1( + void *jarg1, unsigned long jarg2, uint32_t jarg3) { + Dali::Vector *arg1 = (Dali::Vector *)0; + Dali::Vector::SizeType arg2; + Dali::Vector::ItemType *arg3 = 0; + Dali::Vector::ItemType temp3; + + arg1 = (Dali::Vector *)jarg1; + arg2 = (Dali::Vector::SizeType)jarg2; + temp3 = (Dali::Vector::ItemType)jarg3; + arg3 = &temp3; + { + try { + (arg1)->Resize(arg2, (Dali::Vector::ItemType const &)*arg3); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL +CSharp_Dali_VectorUnsignedInteger_Erase__SWIG_0(void *jarg1, uint32_t *jarg2) { + void *jresult; + Dali::Vector *arg1 = (Dali::Vector *)0; + Dali::Vector::Iterator arg2 = (Dali::Vector::Iterator)0; + Dali::Vector::Iterator result; + + arg1 = (Dali::Vector *)jarg1; + arg2 = jarg2; + { + try { + result = (Dali::Vector::Iterator)(arg1)->Erase(arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + return jresult; +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_Erase__SWIG_1( + void *jarg1, uint32_t *jarg2, void *jarg3) { + void *jresult; + Dali::Vector *arg1 = (Dali::Vector *)0; + Dali::Vector::Iterator arg2 = (Dali::Vector::Iterator)0; + Dali::Vector::Iterator arg3 = (Dali::Vector::Iterator)0; + Dali::Vector::Iterator result; + + arg1 = (Dali::Vector *)jarg1; + arg2 = jarg2; + arg3 = (Dali::Vector::Iterator)jarg3; + { + try { + result = (Dali::Vector::Iterator)(arg1)->Erase(arg2, arg3); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_VectorUnsignedInteger_Remove(void *jarg1, uint32_t *jarg2) { + Dali::Vector *arg1 = (Dali::Vector *)0; + Dali::Vector::Iterator arg2 = (Dali::Vector::Iterator)0; + + arg1 = (Dali::Vector *)jarg1; + arg2 = jarg2; + { + try { + (arg1)->Remove(arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_VectorUnsignedInteger_Swap(void *jarg1, void *jarg2) { + Dali::Vector *arg1 = (Dali::Vector *)0; + Dali::Vector *arg2 = 0; + + arg1 = (Dali::Vector *)jarg1; + arg2 = (Dali::Vector *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Dali::Vector< uint32_t > & type is null", 0); + return; + } + { + try { + (arg1)->Swap(*arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_VectorUnsignedInteger_Clear(void *jarg1) { + Dali::Vector *arg1 = (Dali::Vector *)0; + + arg1 = (Dali::Vector *)jarg1; + { + try { + (arg1)->Clear(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_VectorUnsignedInteger_Release(void *jarg1) { + Dali::Vector *arg1 = (Dali::Vector *)0; + + arg1 = (Dali::Vector *)jarg1; + { + try { + (arg1)->Release(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_Size(void *jarg1) { + Dali::Vector< uint32_t > *arg1 = (Dali::Vector< uint32_t > *) 0 ; + int size; + + arg1 = (Dali::Vector *)jarg1; + { + try { + size = (arg1)->Size(); + } CALL_CATCH_EXCEPTION(0); + } + + return size; +} + + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-core/extents-wrap.cpp b/dali-csharp-binder/dali-core/extents-wrap.cpp new file mode 100755 index 00000000..cca07fd2 --- /dev/null +++ b/dali-csharp-binder/dali-core/extents-wrap.cpp @@ -0,0 +1,269 @@ +/* + * Copyright (c) 2021 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Extents__SWIG_0() { + void * jresult ; + Dali::Extents *result = 0 ; + + { + try { + result = (Dali::Extents *)new Dali::Extents(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Extents__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Extents *arg1 = 0 ; + Dali::Extents *result = 0 ; + + arg1 = (Dali::Extents *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Extents const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Extents *)new Dali::Extents((Dali::Extents const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Extents__SWIG_2(unsigned short jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4) { + void * jresult ; + uint16_t arg1 ; + uint16_t arg2 ; + uint16_t arg3 ; + uint16_t arg4 ; + Dali::Extents *result = 0 ; + + arg1 = (uint16_t)jarg1; + arg2 = (uint16_t)jarg2; + arg3 = (uint16_t)jarg3; + arg4 = (uint16_t)jarg4; + { + try { + result = (Dali::Extents *)new Dali::Extents(arg1, arg2, arg3, arg4); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Extents_Assign__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Extents *arg1 = (Dali::Extents *) 0 ; + Dali::Extents *arg2 = 0 ; + Dali::Extents *result = 0 ; + + arg1 = (Dali::Extents *)jarg1; + arg2 = (Dali::Extents *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Extents const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Extents *) &(arg1)->operator =((Dali::Extents const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Extents_Assign__SWIG_1(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Extents *arg1 = (Dali::Extents *) 0 ; + uint16_t *arg2 = (uint16_t *) 0 ; + Dali::Extents *result = 0 ; + + arg1 = (Dali::Extents *)jarg1; + arg2 = (uint16_t *)jarg2; + { + try { + result = (Dali::Extents *) &(arg1)->operator =((uint16_t const *)arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Extents_EqualTo(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::Extents *arg1 = (Dali::Extents *) 0 ; + Dali::Extents *arg2 = 0 ; + bool result; + + arg1 = (Dali::Extents *)jarg1; + arg2 = (Dali::Extents *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Extents const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Extents const *)arg1)->operator ==((Dali::Extents const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Extents_NotEqualTo(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::Extents *arg1 = (Dali::Extents *) 0 ; + Dali::Extents *arg2 = 0 ; + bool result; + + arg1 = (Dali::Extents *)jarg1; + arg2 = (Dali::Extents *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Extents const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Extents const *)arg1)->operator !=((Dali::Extents const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Extents_start_set(void * jarg1, unsigned short jarg2) { + Dali::Extents *arg1 = (Dali::Extents *) 0 ; + uint16_t arg2 ; + + arg1 = (Dali::Extents *)jarg1; + arg2 = (uint16_t)jarg2; + if (arg1) (arg1)->start = arg2; +} + + +SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Extents_start_get(void * jarg1) { + unsigned short jresult ; + Dali::Extents *arg1 = (Dali::Extents *) 0 ; + uint16_t result; + + arg1 = (Dali::Extents *)jarg1; + result = ((arg1)->start); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Extents_end_set(void * jarg1, unsigned short jarg2) { + Dali::Extents *arg1 = (Dali::Extents *) 0 ; + uint16_t arg2 ; + + arg1 = (Dali::Extents *)jarg1; + arg2 = (uint16_t)jarg2; + if (arg1) (arg1)->end = arg2; +} + + +SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Extents_end_get(void * jarg1) { + unsigned short jresult ; + Dali::Extents *arg1 = (Dali::Extents *) 0 ; + uint16_t result; + + arg1 = (Dali::Extents *)jarg1; + result = ((arg1)->end); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Extents_top_set(void * jarg1, unsigned short jarg2) { + Dali::Extents *arg1 = (Dali::Extents *) 0 ; + uint16_t arg2 ; + + arg1 = (Dali::Extents *)jarg1; + arg2 = (uint16_t)jarg2; + if (arg1) (arg1)->top = arg2; +} + + +SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Extents_top_get(void * jarg1) { + unsigned short jresult ; + Dali::Extents *arg1 = (Dali::Extents *) 0 ; + uint16_t result; + + arg1 = (Dali::Extents *)jarg1; + result = ((arg1)->top); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Extents_bottom_set(void * jarg1, unsigned short jarg2) { + Dali::Extents *arg1 = (Dali::Extents *) 0 ; + uint16_t arg2 ; + + arg1 = (Dali::Extents *)jarg1; + arg2 = (uint16_t)jarg2; + if (arg1) (arg1)->bottom = arg2; +} + + +SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Extents_bottom_get(void * jarg1) { + unsigned short jresult ; + Dali::Extents *arg1 = (Dali::Extents *) 0 ; + uint16_t result; + + arg1 = (Dali::Extents *)jarg1; + result = ((arg1)->bottom); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Extents(void * jarg1) { + Dali::Extents *arg1 = (Dali::Extents *) 0 ; + + arg1 = (Dali::Extents *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-core/gestures-wrap.cpp b/dali-csharp-binder/dali-core/gestures-wrap.cpp new file mode 100755 index 00000000..7e51dc45 --- /dev/null +++ b/dali-csharp-binder/dali-core/gestures-wrap.cpp @@ -0,0 +1,442 @@ +/* + * Copyright (c) 2020 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + +using namespace Dali; + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > const *self) +{ + return self->Empty(); +} + +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > const *self) +{ + return self->GetConnectionCount(); +} + +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *self,void (*func)(Dali::Actor,Dali::RotationGesture const &)) +{ + self->Connect( func ); +} + +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *self,void (*func)(Dali::Actor,Dali::RotationGesture const &)) +{ + self->Disconnect( func ); +} + +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *self,Dali::Actor arg1,Dali::RotationGesture const &arg2) +{ + self->Emit( arg1, arg2 ); +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RotationGestureDetector__SWIG_0() +{ + void * jresult ; + Dali::RotationGestureDetector *result = 0 ; + + { + try { + result = (Dali::RotationGestureDetector *)new Dali::RotationGestureDetector(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGestureDetector_New() { + void * jresult ; + Dali::RotationGestureDetector result; + + { + try { + result = Dali::RotationGestureDetector::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::RotationGestureDetector((const Dali::RotationGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGestureDetector_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::RotationGestureDetector 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::RotationGestureDetector::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::RotationGestureDetector((const Dali::RotationGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RotationGestureDetector(void * jarg1) { + Dali::RotationGestureDetector *arg1 = (Dali::RotationGestureDetector *) 0 ; + + arg1 = (Dali::RotationGestureDetector *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RotationGestureDetector__SWIG_1(void * jarg1) { + void * jresult ; + Dali::RotationGestureDetector *arg1 = 0 ; + Dali::RotationGestureDetector *result = 0 ; + + arg1 = (Dali::RotationGestureDetector *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RotationGestureDetector const & type is null", 0); + return 0; + } + { + try { + result = (Dali::RotationGestureDetector *)new Dali::RotationGestureDetector((Dali::RotationGestureDetector const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGestureDetector_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::RotationGestureDetector *arg1 = (Dali::RotationGestureDetector *) 0 ; + Dali::RotationGestureDetector *arg2 = 0 ; + Dali::RotationGestureDetector *result = 0 ; + + arg1 = (Dali::RotationGestureDetector *)jarg1; + arg2 = (Dali::RotationGestureDetector *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RotationGestureDetector const & type is null", 0); + return 0; + } + { + try { + result = (Dali::RotationGestureDetector *) &(arg1)->operator =((Dali::RotationGestureDetector const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGestureDetector_DetectedSignal(void * jarg1) { + void * jresult ; + Dali::RotationGestureDetector *arg1 = (Dali::RotationGestureDetector *) 0 ; + Dali::RotationGestureDetector::DetectedSignalType *result = 0 ; + + arg1 = (Dali::RotationGestureDetector *)jarg1; + { + try { + result = (Dali::RotationGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RotationGesture__SWIG_0() { + void * jresult ; + Dali::RotationGesture *result = 0 ; + + { + try { + result = (Dali::RotationGesture *)new Dali::RotationGesture(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGesture_New(int jarg1) { + void * jresult ; + Dali::GestureState arg1 ; + Dali::RotationGesture result; + + arg1 = (Dali::GestureState)jarg1; + { + try { + result = DevelRotationGesture::New(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::RotationGesture((const Dali::RotationGesture &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RotationGesture__SWIG_1(void * jarg1) { + void * jresult ; + Dali::RotationGesture *arg1 = 0 ; + Dali::RotationGesture *result = 0 ; + + arg1 = (Dali::RotationGesture *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RotationGesture const & type is null", 0); + return 0; + } + { + try { + result = (Dali::RotationGesture *)new Dali::RotationGesture((Dali::RotationGesture const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGesture_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::RotationGesture *arg1 = (Dali::RotationGesture *) 0 ; + Dali::RotationGesture *arg2 = 0 ; + Dali::RotationGesture *result = 0 ; + + arg1 = (Dali::RotationGesture *)jarg1; + arg2 = (Dali::RotationGesture *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RotationGesture const & type is null", 0); + return 0; + } + { + try { + result = (Dali::RotationGesture *) &(arg1)->operator =((Dali::RotationGesture const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RotationGesture(void * jarg1) { + Dali::RotationGesture *arg1 = (Dali::RotationGesture *) 0 ; + + arg1 = (Dali::RotationGesture *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RotationGesture_rotation_get(void * jarg1) { + float jresult ; + Dali::RotationGesture *arg1 = (Dali::RotationGesture *) 0 ; + float result; + + arg1 = (Dali::RotationGesture *)jarg1; + result = (float) ((arg1)->GetRotation().radian); + jresult = result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGesture_screenCenterPoint_get(void * jarg1) { + void * jresult ; + Dali::RotationGesture *arg1 = (Dali::RotationGesture *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::RotationGesture *)jarg1; + { + try { + result = ((Dali::RotationGesture const *)arg1)->GetScreenCenterPoint(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGesture_localCenterPoint_get(void * jarg1) { + void * jresult ; + Dali::RotationGesture *arg1 = (Dali::RotationGesture *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::RotationGesture *)jarg1; + { + try { + result = ((Dali::RotationGesture const *)arg1)->GetLocalCenterPoint(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RotationGestureDetectedSignal_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_RotationGestureDetectedSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RotationGestureDetectedSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *) 0 ; + void (*arg2)(Dali::Actor,Dali::RotationGesture const &) = (void (*)(Dali::Actor,Dali::RotationGesture const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)jarg1; + arg2 = (void (*)(Dali::Actor,Dali::RotationGesture const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RotationGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *) 0 ; + void (*arg2)(Dali::Actor,Dali::RotationGesture const &) = (void (*)(Dali::Actor,Dali::RotationGesture const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)jarg1; + arg2 = (void (*)(Dali::Actor,Dali::RotationGesture const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RotationGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) { + Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *) 0 ; + Dali::Actor arg2 ; + Dali::RotationGesture *arg3 = 0 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::RotationGesture *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RotationGesture const & type is null", 0); + return ; + } + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::RotationGesture const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RotationGestureDetectedSignal() { + void * jresult ; + Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RotationGestureDetectedSignal(void * jarg1) { + Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_RotationGestureDetector_SWIGUpcast(Dali::RotationGestureDetector *jarg1) { + return (Dali::GestureDetector *)jarg1; +} + +SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_RotationGesture_SWIGUpcast(Dali::RotationGesture *jarg1) { + return (Dali::Gesture *)jarg1; +} + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/dali-core/input-options-wrap.cpp b/dali-csharp-binder/dali-core/input-options-wrap.cpp new file mode 100644 index 00000000..e8deac1b --- /dev/null +++ b/dali-csharp-binder/dali-core/input-options-wrap.cpp @@ -0,0 +1,258 @@ +/* + * Copyright (c) 2021 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +using namespace Dali; + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGesturePredictionMode(int mode) { + { + try { + Integration::SetPanGesturePredictionMode(mode); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGesturePredictionAmount(unsigned int amount) { + { + try { + Integration::SetPanGesturePredictionAmount(amount); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureMaximumPredictionAmount(unsigned int amount) { + { + try { + Integration::SetPanGestureMaximumPredictionAmount(amount); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureMinimumPredictionAmount(unsigned int amount) { + { + try { + Integration::SetPanGestureMinimumPredictionAmount(amount); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGesturePredictionAmountAdjustment(unsigned int amount) { + { + try { + Integration::SetPanGesturePredictionAmountAdjustment(amount); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureSmoothingMode(int mode) { + { + try { + Integration::SetPanGestureSmoothingMode(mode); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureSmoothingAmount(float amount) { + { + try { + Integration::SetPanGestureSmoothingAmount(amount); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureUseActualTimes(bool enable) { + { + try { + Integration::SetPanGestureUseActualTimes(enable); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureInterpolationTimeRange(int range) { + { + try { + Integration::SetPanGestureInterpolationTimeRange(range); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureScalarOnlyPredictionEnabled(bool enable) { + { + try { + Integration::SetPanGestureScalarOnlyPredictionEnabled(enable); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureTwoPointPredictionEnabled(bool enable) { + { + try { + Integration::SetPanGestureTwoPointPredictionEnabled(enable); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureTwoPointInterpolatePastTime(int time) { + { + try { + Integration::SetPanGestureTwoPointInterpolatePastTime(time); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureTwoPointVelocityBias(float velocity) { + { + try { + Integration::SetPanGestureTwoPointVelocityBias(velocity); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureTwoPointAccelerationBias(float acceleration) { + { + try { + Integration::SetPanGestureTwoPointAccelerationBias(acceleration); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureMultitapSmoothingRange(int range) { + { + try { + Integration::SetPanGestureMultitapSmoothingRange(range); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureMinimumDistance(int distance) { + { + try { + Integration::SetPanGestureMinimumDistance(distance); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureMinimumPanEvents(int number) { + { + try { + Integration::SetPanGestureMinimumPanEvents(number); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPinchGestureMinimumDistance(float distance) { + { + try { + Integration::SetPinchGestureMinimumDistance(distance); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPinchGestureMinimumTouchEvents(unsigned int number) { + { + try { + Integration::SetPinchGestureMinimumTouchEvents(number); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPinchGestureMinimumTouchEventsAfterStart(unsigned int number) { + { + try { + Integration::SetPinchGestureMinimumTouchEventsAfterStart(number); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetRotationGestureMinimumTouchEvents(unsigned int number) { + { + try { + Integration::SetRotationGestureMinimumTouchEvents(number); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetRotationGestureMinimumTouchEventsAfterStart(unsigned int number) { + { + try { + Integration::SetRotationGestureMinimumTouchEventsAfterStart(number); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetLongPressMinimumHoldingTime(unsigned int time) { + { + try { + Integration::SetLongPressMinimumHoldingTime(time); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetTapMaximumAllowedTime(uint32_t time) { + { + try { + Integration::SetTapMaximumAllowedTime(time); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetTapRecognizerTime(uint32_t time) { + { + try { + Integration::SetTapRecognizerTime(time); + } CALL_CATCH_EXCEPTION(); + } + return; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-core/internal-property-get-set-wrap.cpp b/dali-csharp-binder/dali-core/internal-property-get-set-wrap.cpp new file mode 100755 index 00000000..37daee5c --- /dev/null +++ b/dali-csharp-binder/dali-core/internal-property-get-set-wrap.cpp @@ -0,0 +1,590 @@ +/* + * Copyright (c) 2022 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); + extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + + enum InternalPropertyReturnType + { + NO_ERROR = 0, + ERROR_UNKNOWN = 1, + ERROR_IMPOSSIBLE_SET = 2, + }; + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalSetPropertyVector2(void *actor, int propertyType, void *vector2) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + Dali::Vector2 *pVector2 = (Dali::Vector2 *)vector2; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + if (!pVector2) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector2 is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + pActor->SetProperty((Dali::Property::Index)propertyType, *pVector2); + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalSetPropertyVector3(void *actor, int propertyType, void *vector3) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + Dali::Vector3 *pVector3 = (Dali::Vector3 *)vector3; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + if (!pVector3) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector3 is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + pActor->SetProperty((Dali::Property::Index)propertyType, *pVector3); + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalSetPropertyVector4(void *actor, int propertyType, void *vector4) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + Dali::Vector4 *pVector4 = (Dali::Vector4 *)vector4; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + if (!pVector4) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector4 is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + pActor->SetProperty((Dali::Property::Index)propertyType, *pVector4); + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalSetPropertyVector2ActualVector3(void *actor, int propertyType, void *vector2) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + Dali::Vector2 *pVector2 = (Dali::Vector2 *)vector2; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + if (!pVector2) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector2 is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + pActor->SetProperty((Dali::Property::Index)propertyType, Dali::Vector3(pVector2->x, pVector2->y, 0)); + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalSetPropertyFloat(void *actor, int propertyType, float valFloat) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + pActor->SetProperty((Dali::Property::Index)propertyType, valFloat); + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalSetPropertyBool(void *actor, int propertyType, bool valBool) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + pActor->SetProperty((Dali::Property::Index)propertyType, valBool); + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalSetPropertyString(void *actor, int propertyType, char *valString) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + if (!valString) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "valString is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + pActor->SetProperty((Dali::Property::Index)propertyType, (std::string const &)std::string(valString)); + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalSetPropertyInt(void *actor, int propertyType, int valInt) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + pActor->SetProperty((Dali::Property::Index)propertyType, valInt); + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalRetrievingPropertyVector2(void *actor, int propertyType, void *retrievingVector2) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + Dali::Vector2 *pVector2 = (Dali::Vector2 *)retrievingVector2; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + if (!pVector2) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector2 is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + Dali::Vector2 result; + result = ((Dali::Actor const *)pActor)->GetProperty((Dali::Property::Index)propertyType); + pVector2->x = result.x; + pVector2->y = result.y; + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalRetrievingPropertyVector3(void *actor, int propertyType, void *retrievingVector3) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + Dali::Vector3 *pVector3 = (Dali::Vector3 *)retrievingVector3; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + if (!pVector3) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector3 is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + Dali::Vector3 result; + result = ((Dali::Actor const *)pActor)->GetProperty((Dali::Property::Index)propertyType); + pVector3->x = result.x; + pVector3->y = result.y; + pVector3->z = result.z; + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalRetrievingPropertyVector4(void *actor, int propertyType, void *retrievingVector4) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + Dali::Vector4 *pVector4 = (Dali::Vector4 *)retrievingVector4; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + if (!pVector4) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector4 is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + Dali::Vector4 result; + result = ((Dali::Actor const *)pActor)->GetProperty((Dali::Property::Index)propertyType); + pVector4->x = result.x; + pVector4->y = result.y; + pVector4->z = result.z; + pVector4->w = result.w; + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalRetrievingPropertyVector2ActualVector3(void *actor, int propertyType, void *retrievingVector2) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + Dali::Vector2 *pVector2 = (Dali::Vector2 *)retrievingVector2; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + if (!pVector2) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector2 is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + Dali::Vector3 result; + result = ((Dali::Actor const *)pActor)->GetProperty((Dali::Property::Index)propertyType); + pVector2->x = result.x; + pVector2->y = result.y; + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalRetrievingPropertyFloat(void *actor, int propertyType, float *valFloat) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + if (!valFloat) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "valFloat is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + *valFloat = ((Dali::Actor const *)pActor)->GetProperty((Dali::Property::Index)propertyType); + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_InternalGetPropertyFloat(void *actor, int propertyType) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + float ret = 0; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return ret; + } + + try + { + ret = ((Dali::Actor const *)pActor)->GetProperty((Dali::Property::Index)propertyType); + } + CALL_CATCH_EXCEPTION(ret); + + return ret; + } + + SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_InternalGetPropertyBool(void *actor, int propertyType) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + bool ret = false; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return ret; + } + + try + { + ret = ((Dali::Actor const *)pActor)->GetProperty((Dali::Property::Index)propertyType); + } + CALL_CATCH_EXCEPTION(ret); + + return ret; + } + + SWIGEXPORT char *SWIGSTDCALL CSharp_Dali_Actor_InternalGetPropertyString(void *actor, int propertyType) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + std::string result = ""; + char *ret = nullptr; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return ret; + } + + try + { + result = ((Dali::Actor const *)pActor)->GetProperty((Dali::Property::Index)propertyType); + ret = SWIG_csharp_string_callback(result.c_str()); + } + CALL_CATCH_EXCEPTION(ret); + + return ret; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalGetPropertyInt(void *actor, int propertyType) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + int ret = 0; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return ret; + } + + try + { + ret = ((Dali::Actor const *)pActor)->GetProperty((Dali::Property::Index)propertyType); + } + CALL_CATCH_EXCEPTION(ret); + + return ret; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_RetrieveTargetSize(void *actor, void *retrievingVector3) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + Dali::Vector3 *pVector3 = (Dali::Vector3 *)retrievingVector3; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + if (!pVector3) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector3 is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + Dali::Vector3 result; + result = ((Dali::Actor const *)pActor)->GetTargetSize(); + pVector3->x = result.x; + pVector3->y = result.y; + pVector3->z = result.z; + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_RetrieveCurrentPropertyVector3(void *actor, int propertyType, void *retrievingVector3) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + Dali::Vector3 *pVector3 = (Dali::Vector3 *)retrievingVector3; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + if (!pVector3) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector3 is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + Dali::Vector3 result; + result = ((Dali::Actor const *)pActor)->GetCurrentProperty((Dali::Property::Index)propertyType); + pVector3->x = result.x; + pVector3->y = result.y; + pVector3->z = result.z; + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_RetrieveCurrentPropertyVector2ActualVector3(void *actor, int propertyType, void *retrievingVector2) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + Dali::Vector2 *pVector2 = (Dali::Vector2 *)retrievingVector2; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + if (!pVector2) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector2 is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + Dali::Vector3 result; + result = ((Dali::Actor const *)pActor)->GetCurrentProperty((Dali::Property::Index)propertyType); + pVector2->x = result.x; + pVector2->y = result.y; + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_RetrieveNaturalSize(void *actor, void *retrievingVector3) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + Dali::Vector3 *pVector3 = (Dali::Vector3 *)retrievingVector3; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + if (!pVector3) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector3 is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + Dali::Vector3 result; + result = ((Dali::Actor const *)pActor)->GetNaturalSize(); + pVector3->x = result.x; + pVector3->y = result.y; + pVector3->z = result.z; + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_RetrieveCurrentPropertyVector4(void *actor, int propertyType, void *retrievingVector4) + { + Dali::Actor *pActor = (Dali::Actor *)actor; + Dali::Vector4 *pVector4 = (Dali::Vector4 *)retrievingVector4; + + if (!pActor) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + if (!pVector4) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector4 is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + Dali::Vector4 result; + result = ((Dali::Actor const *)pActor)->GetCurrentProperty((Dali::Property::Index)propertyType); + pVector4->x = result.x; + pVector4->y = result.y; + pVector4->z = result.z; + pVector4->w = result.w; + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-core/layer-wrap.cpp b/dali-csharp-binder/dali-core/layer-wrap.cpp new file mode 100644 index 00000000..771fa15e --- /dev/null +++ b/dali-csharp-binder/dali-core/layer-wrap.cpp @@ -0,0 +1,652 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +using namespace Dali; + +#ifdef __cplusplus +extern "C" { +#endif + +// Property + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() +{ + int jresult; + int result; + + result = (int)Dali::Layer::Property::CLIPPING_ENABLE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() +{ + int jresult; + int result; + + result = (int)Dali::Layer::Property::CLIPPING_BOX; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() +{ + int jresult; + int result; + + result = (int)Dali::Layer::Property::BEHAVIOR; + jresult = (int)result; + return jresult; +} + +// Creation + +SWIGEXPORT Dali::Actor* SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer* jarg1) +{ + return (Dali::Actor*)jarg1; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Layer_Property() +{ + void* jresult; + Dali::Layer::Property* result = 0; + + { + try + { + result = (Dali::Layer::Property*)new Dali::Layer::Property(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void* jarg1) +{ + Dali::Layer::Property* arg1 = (Dali::Layer::Property*)0; + + arg1 = (Dali::Layer::Property*)jarg1; + { + try + { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() +{ + void* jresult; + Dali::Layer* result = 0; + + { + try + { + result = (Dali::Layer*)new Dali::Layer(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Layer_New() +{ + void* jresult; + Dali::Layer result; + + { + try + { + result = Dali::Layer::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Layer((const Dali::Layer&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Layer_DownCast(void* jarg1) +{ + void* jresult; + Dali::BaseHandle arg1; + Dali::BaseHandle* argp1; + Dali::Layer 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::Layer::DownCast(arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Layer((const Dali::Layer&)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void* jarg1) +{ + Dali::Layer* arg1 = (Dali::Layer*)0; + + arg1 = (Dali::Layer*)jarg1; + { + try + { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void* jarg1) +{ + void* jresult; + Dali::Layer* arg1 = 0; + Dali::Layer* result = 0; + + arg1 = (Dali::Layer*)jarg1; + if(!arg1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Layer*)new Dali::Layer((Dali::Layer const&)*arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Layer_Assign(void* jarg1, void* jarg2) +{ + void* jresult; + Dali::Layer* arg1 = (Dali::Layer*)0; + Dali::Layer* arg2 = 0; + Dali::Layer* result = 0; + + arg1 = (Dali::Layer*)jarg1; + arg2 = (Dali::Layer*)jarg2; + if(!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Layer*)&(arg1)->operator=((Dali::Layer const&)*arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +// Method + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void* jarg1) +{ + unsigned int jresult; + Dali::Layer* arg1 = (Dali::Layer*)0; + unsigned int result; + + arg1 = (Dali::Layer*)jarg1; + { + try + { + result = (unsigned int)((Dali::Layer const*)arg1)->GetProperty(Layer::Property::DEPTH); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void* jarg1) +{ + Dali::Layer* arg1 = (Dali::Layer*)0; + + arg1 = (Dali::Layer*)jarg1; + { + try + { + (arg1)->Raise(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void* jarg1) +{ + Dali::Layer* arg1 = (Dali::Layer*)0; + + arg1 = (Dali::Layer*)jarg1; + { + try + { + (arg1)->Lower(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void* jarg1, void* jarg2) +{ + Dali::Layer* arg1 = (Dali::Layer*)0; + Dali::Layer arg2; + Dali::Layer* argp2; + + arg1 = (Dali::Layer*)jarg1; + argp2 = (Dali::Layer*)jarg2; + if(!argp2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0); + return; + } + arg2 = *argp2; + { + try + { + (arg1)->RaiseAbove(arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void* jarg1, void* jarg2) +{ + Dali::Layer* arg1 = (Dali::Layer*)0; + Dali::Layer arg2; + Dali::Layer* argp2; + + arg1 = (Dali::Layer*)jarg1; + argp2 = (Dali::Layer*)jarg2; + if(!argp2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0); + return; + } + arg2 = *argp2; + { + try + { + (arg1)->LowerBelow(arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void* jarg1) +{ + Dali::Layer* arg1 = (Dali::Layer*)0; + + arg1 = (Dali::Layer*)jarg1; + { + try + { + (arg1)->RaiseToTop(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void* jarg1) +{ + Dali::Layer* arg1 = (Dali::Layer*)0; + + arg1 = (Dali::Layer*)jarg1; + { + try + { + (arg1)->LowerToBottom(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void* jarg1, void* jarg2) +{ + Dali::Layer* arg1 = (Dali::Layer*)0; + Dali::Layer arg2; + Dali::Layer* argp2; + + arg1 = (Dali::Layer*)jarg1; + argp2 = (Dali::Layer*)jarg2; + if(!argp2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0); + return; + } + arg2 = *argp2; + { + try + { + (arg1)->MoveAbove(arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void* jarg1, void* jarg2) +{ + Dali::Layer* arg1 = (Dali::Layer*)0; + Dali::Layer arg2; + Dali::Layer* argp2; + + arg1 = (Dali::Layer*)jarg1; + argp2 = (Dali::Layer*)jarg2; + if(!argp2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0); + return; + } + arg2 = *argp2; + { + try + { + (arg1)->MoveBelow(arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void* jarg1, int jarg2) +{ + Dali::Layer* arg1 = (Dali::Layer*)0; + Dali::Layer::Behavior arg2; + + arg1 = (Dali::Layer*)jarg1; + arg2 = (Dali::Layer::Behavior)jarg2; + { + try + { + (arg1)->SetProperty(Layer::Property::BEHAVIOR, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void* jarg1) +{ + int jresult; + Dali::Layer* arg1 = (Dali::Layer*)0; + Dali::Layer::Behavior result; + + arg1 = (Dali::Layer*)jarg1; + { + try + { + result = (Dali::Layer::Behavior)((Dali::Layer const*)arg1)->GetProperty(Dali::Layer::Property::BEHAVIOR); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void* jarg1, bool jarg2) +{ + Dali::Layer* arg1 = (Dali::Layer*)0; + bool arg2; + + arg1 = (Dali::Layer*)jarg1; + arg2 = jarg2 ? true : false; + { + try + { + (arg1)->SetProperty(Dali::Layer::Property::CLIPPING_ENABLE, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void* jarg1) +{ + bool jresult; + Dali::Layer* arg1 = (Dali::Layer*)0; + bool result; + + arg1 = (Dali::Layer*)jarg1; + { + try + { + result = (bool)((Dali::Layer const*)arg1)->GetProperty(Dali::Layer::Property::CLIPPING_ENABLE); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void* jarg1, int jarg2, int jarg3, int jarg4, int jarg5) +{ + Dali::Layer* arg1 = (Dali::Layer*)0; + int arg2; + int arg3; + int arg4; + int arg5; + + arg1 = (Dali::Layer*)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + arg4 = (int)jarg4; + arg5 = (int)jarg5; + { + try + { + (arg1)->SetProperty(Dali::Layer::Property::CLIPPING_BOX, Rect(arg2, arg3, arg4, arg5)); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void* jarg1, void* jarg2) +{ + Dali::Layer* arg1 = (Dali::Layer*)0; + Dali::ClippingBox arg2; + Dali::ClippingBox* argp2; + + arg1 = (Dali::Layer*)jarg1; + argp2 = (Dali::ClippingBox*)jarg2; + if(!argp2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0); + return; + } + arg2 = *argp2; + { + try + { + (arg1)->SetProperty(Dali::Layer::Property::CLIPPING_BOX, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void* jarg1) +{ + void* jresult; + Dali::Layer* arg1 = (Dali::Layer*)0; + Dali::ClippingBox result; + + arg1 = (Dali::Layer*)jarg1; + { + try + { + result = ((Dali::Layer const*)arg1)->GetProperty >(Layer::Property::CLIPPING_BOX); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::ClippingBox((const Dali::ClippingBox&)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void* jarg1, bool jarg2) +{ + Dali::Layer* arg1 = (Dali::Layer*)0; + bool arg2; + + arg1 = (Dali::Layer*)jarg1; + arg2 = jarg2 ? true : false; + { + try + { + (arg1)->SetProperty(Layer::Property::DEPTH_TEST, !arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void* jarg1) +{ + bool jresult; + Dali::Layer* arg1 = (Dali::Layer*)0; + bool result; + + arg1 = (Dali::Layer*)jarg1; + { + try + { + result = !(bool)((Dali::Layer const*)arg1)->GetProperty(Layer::Property::DEPTH_TEST); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void* jarg1, void* jarg2) +{ + Dali::Layer* arg1 = (Dali::Layer*)0; + Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType)0; + + arg1 = (Dali::Layer*)jarg1; + arg2 = (Dali::Layer::SortFunctionType)jarg2; + { + try + { + (arg1)->SetSortFunction(arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void* jarg1, bool jarg2) +{ + Dali::Layer* arg1 = (Dali::Layer*)0; + bool arg2; + + arg1 = (Dali::Layer*)jarg1; + arg2 = jarg2 ? true : false; + { + try + { + (arg1)->SetProperty(Layer::Property::CONSUMES_TOUCH, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void* jarg1) +{ + bool jresult; + Dali::Layer* arg1 = (Dali::Layer*)0; + bool result; + + arg1 = (Dali::Layer*)jarg1; + { + try + { + result = (bool)((Dali::Layer const*)arg1)->GetProperty(Layer::Property::CONSUMES_TOUCH); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void* jarg1, bool jarg2) +{ + Dali::Layer* arg1 = (Dali::Layer*)0; + bool arg2; + + arg1 = (Dali::Layer*)jarg1; + arg2 = jarg2 ? true : false; + { + try + { + (arg1)->SetProperty(Layer::Property::CONSUMES_HOVER, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void* jarg1) +{ + bool jresult; + Dali::Layer* arg1 = (Dali::Layer*)0; + bool result; + + arg1 = (Dali::Layer*)jarg1; + { + try + { + result = (bool)((Dali::Layer const*)arg1)->GetProperty(Layer::Property::CONSUMES_HOVER); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-core/ref-object-wrap.cpp b/dali-csharp-binder/dali-core/ref-object-wrap.cpp new file mode 100644 index 00000000..9fe5bd53 --- /dev/null +++ b/dali-csharp-binder/dali-core/ref-object-wrap.cpp @@ -0,0 +1,230 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +// SWIGINTERN - the relevant parts of the generated code can be seen the below. + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)) +{ + self->Connect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)) +{ + self->Disconnect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg) +{ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit(arg); +} + +using namespace Dali; + +#ifdef __cplusplus +extern "C" { +#endif + + +// Creation + +SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) { + return (Dali::RefObject *)jarg1; +} + + +SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) { + Dali::RefObject *result = NULL; + + if (arg1) + { + result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr(); + } + return result; +} + + +// Method + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) { + Dali::RefObject *arg1 = (Dali::RefObject *) 0 ; + + arg1 = (Dali::RefObject *)jarg1; + { + try { + (arg1)->Reference(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) { + Dali::RefObject *arg1 = (Dali::RefObject *) 0 ; + + arg1 = (Dali::RefObject *)jarg1; + { + try { + (arg1)->Unreference(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) { + int jresult ; + Dali::RefObject *arg1 = (Dali::RefObject *) 0 ; + int result; + + arg1 = (Dali::RefObject *)jarg1; + { + try { + result = (int)(arg1)->ReferenceCount(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +// Signals + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ; + void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ; + + arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1; + arg2 = (void (*)(Dali::RefObject const *))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ; + void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ; + + arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1; + arg2 = (void (*)(Dali::RefObject const *))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ; + Dali::RefObject *arg2 = (Dali::RefObject *) 0 ; + + arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1; + arg2 = (Dali::RefObject *)jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() { + void * jresult ; + Dali::Signal< void (Dali::RefObject const *) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) { + Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-core/rotation-wrap.cpp b/dali-csharp-binder/dali-core/rotation-wrap.cpp new file mode 100644 index 00000000..b1f8ed9c --- /dev/null +++ b/dali-csharp-binder/dali-core/rotation-wrap.cpp @@ -0,0 +1,988 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Rotation_0() +{ + void* jresult; + Dali::Quaternion* result = 0; + + { + try + { + result = (Dali::Quaternion*)new Dali::Quaternion(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Rotation_1(void* nuiRadianAngle, void* nuiVector3) +{ + void* jresult; + Dali::Radian* radian = (Dali::Radian*)nuiRadianAngle; + Dali::Vector3* vector = (Dali::Vector3*)nuiVector3; + Dali::Quaternion* result = 0; + + if(!radian) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return 0; + } + if(!vector) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Quaternion*)new Dali::Quaternion(*radian, (Dali::Vector3 const&)*vector); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Rotation_2(void* nuiV0, void* nuiV1) +{ + void* jresult; + Dali::Vector3* v0 = (Dali::Vector3*)nuiV0; + Dali::Vector3* v1 = (Dali::Vector3*)nuiV1; + Dali::Quaternion* result = 0; + + if(!v0) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + if(!v1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Quaternion*)new Dali::Quaternion((Dali::Vector3 const&)*v0, (Dali::Vector3 const&)*v1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Rotation_3(void* nuiPitchRadian, void* nuiYawRadian, void* nuiRollRadian) +{ + void* jresult; + Dali::Radian* pitch = (Dali::Radian*)nuiPitchRadian; + Dali::Radian* yaw = (Dali::Radian*)nuiYawRadian; + Dali::Radian* roll = (Dali::Radian*)nuiRollRadian; + Dali::Quaternion* result = 0; + + if(!pitch) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type pitch is null", 0); + return 0; + } + if(!yaw) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type yaw is null", 0); + return 0; + } + if(!roll) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type roll is null", 0); + return 0; + } + { + try + { + result = (Dali::Quaternion*)new Dali::Quaternion((Dali::Radian const&)*pitch, (Dali::Radian const&)*yaw, (Dali::Radian const&)*roll); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Rotation_4(void* nuiVector4) +{ + void* jresult; + Dali::Vector4* vector4 = (Dali::Vector4*)nuiVector4; + Dali::Quaternion* result = 0; + + if(!vector4) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type vector4 is null", 0); + return 0; + } + { + try + { + result = (Dali::Quaternion*)new Dali::Quaternion((Dali::Vector4 const&)*vector4); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void* nuiRotation) +{ + Dali::Quaternion* quaternion = (Dali::Quaternion*)0; + + quaternion = (Dali::Quaternion*)nuiRotation; + { + try + { + delete quaternion; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() +{ + void* jresult; + Dali::Quaternion* result = 0; + + result = (Dali::Quaternion*)&Dali::Quaternion::IDENTITY; + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void* nuiRotation) +{ + bool result; + Dali::Quaternion* quaternion = (Dali::Quaternion*)0; + + quaternion = (Dali::Quaternion*)nuiRotation; + { + try + { + result = (bool)((Dali::Quaternion const*)quaternion)->IsIdentity(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void* nuiRotation, void* nuiAxis, void* nuiRadianAngle) +{ + bool result; + Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; + Dali::Vector3* axis = (Dali::Vector3*)nuiAxis; + Dali::Radian* radian = (Dali::Radian*)nuiRadianAngle; + + if(!axis) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); + return 0; + } + if(!radian) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0); + return 0; + } + { + try + { + result = (bool)((Dali::Quaternion const*)quaternion)->ToAxisAngle(*axis, *radian); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_SetEulerAngle(void* nuiRotation, void* nuiPitchRadian, void* nuiYawRadian, void* nuiRollRadian) +{ + Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; + Dali::Radian* pitch = (Dali::Radian*)nuiPitchRadian; + Dali::Radian* yaw = (Dali::Radian*)nuiYawRadian; + Dali::Radian* roll = (Dali::Radian*)nuiRollRadian; + + if(!pitch) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type pitch is null", 0); + return; + } + if(!yaw) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type yaw is null", 0); + return; + } + if(!roll) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type roll is null", 0); + return; + } + { + try + { + ((Dali::Quaternion*)quaternion)->SetEuler((Dali::Radian const&)*pitch, (Dali::Radian const&)*yaw, (Dali::Radian const&)*roll); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_GetEulerAngle(void* nuiRotation, void* nuiPitchRadian, void* nuiYawRadian, void* nuiRollRadian) +{ + Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; + Dali::Radian* pitch = (Dali::Radian*)nuiPitchRadian; + Dali::Radian* yaw = (Dali::Radian*)nuiYawRadian; + Dali::Radian* roll = (Dali::Radian*)nuiRollRadian; + + if(!pitch) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type pitch is null", 0); + return; + } + if(!yaw) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type yaw is null", 0); + return; + } + if(!roll) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type roll is null", 0); + return; + } + { + try + { + Dali::Vector4 result = (Dali::Vector4)((Dali::Quaternion const*)quaternion)->EulerAngles(); + // Convert from EulerAngles to pitch / yaw / roll + *pitch = Dali::Radian(result.x); + *yaw = Dali::Radian(result.y); + *roll = Dali::Radian(result.z); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Add(void* nuiRotation0, void* nuiRotation1) +{ + void* jresult; + Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; + Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; + Dali::Quaternion result; + + if(!quaternion1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + { + try + { + result = ((Dali::Quaternion const*)quaternion0)->operator+((Dali::Quaternion const&)*quaternion1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Quaternion((const Dali::Quaternion&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Subtract_0(void* nuiRotation0, void* nuiRotation1) +{ + void* jresult; + Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; + Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; + Dali::Quaternion result; + + if(!quaternion1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + { + try + { + result = ((Dali::Quaternion const*)quaternion0)->operator-((Dali::Quaternion const&)*quaternion1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Quaternion((const Dali::Quaternion&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Multiply_0(void* nuiRotation0, void* nuiRotation1) +{ + void* jresult; + Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; + Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; + Dali::Quaternion result; + + if(!quaternion1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + { + try + { + result = ((Dali::Quaternion const*)quaternion0)->operator*((Dali::Quaternion const&)*quaternion1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Quaternion((const Dali::Quaternion&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Multiply_1(void* nuiRotation, void* nuiVector3) +{ + void* jresult; + Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; + Dali::Vector3* vector = (Dali::Vector3*)nuiVector3; + Dali::Vector3 result; + + if(!vector) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try + { + result = ((Dali::Quaternion const*)quaternion)->operator*((Dali::Vector3 const&)*vector); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Divide_0(void* nuiRotation0, void* nuiRotation1) +{ + void* jresult; + Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; + Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; + Dali::Quaternion result; + + if(!quaternion1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + { + try + { + result = ((Dali::Quaternion const*)quaternion0)->operator/((Dali::Quaternion const&)*quaternion1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Quaternion((const Dali::Quaternion&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Multiply_2(void* nuiRotation, float scale) +{ + void* jresult; + Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; + Dali::Quaternion result; + { + try + { + result = ((Dali::Quaternion const*)quaternion)->operator*(scale); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Quaternion((const Dali::Quaternion&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Divide_1(void* nuiRotation, float scale) +{ + void* jresult; + Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; + Dali::Quaternion result; + { + try + { + result = ((Dali::Quaternion const*)quaternion)->operator/(scale); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Quaternion((const Dali::Quaternion&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Subtract_1(void* nuiRotation) +{ + void* jresult; + Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; + Dali::Quaternion result; + + { + try + { + result = ((Dali::Quaternion const*)quaternion)->operator-(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Quaternion((const Dali::Quaternion&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void* nuiRotation0, void* nuiRotation1) +{ + void* jresult; + Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; + Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; + Dali::Quaternion* result = 0; + + if(!quaternion1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Quaternion*)&(quaternion0)->operator+=((Dali::Quaternion const&)*quaternion1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void* nuiRotation0, void* nuiRotation1) +{ + void* jresult; + Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; + Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; + Dali::Quaternion* result = 0; + + if(!quaternion1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Quaternion*)&(quaternion0)->operator-=((Dali::Quaternion const&)*quaternion1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign_0(void* nuiRotation0, void* nuiRotation1) +{ + void* jresult; + Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; + Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; + Dali::Quaternion* result = 0; + + if(!quaternion1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Quaternion*)&(quaternion0)->operator*=((Dali::Quaternion const&)*quaternion1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign_1(void* nuiRotation, float scale) +{ + void* jresult; + Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; + Dali::Quaternion* result; + { + try + { + result = (Dali::Quaternion*)&(quaternion)->operator*=(scale); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void* nuiRotation, float scale) +{ + void* jresult; + Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; + Dali::Quaternion* result; + { + try + { + result = (Dali::Quaternion*)&(quaternion)->operator/=(scale); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void*)result; + return jresult; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void* nuiRotation0, void* nuiRotation1) +{ + bool result; + Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; + Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; + + if(!quaternion1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + { + try + { + result = (bool)((Dali::Quaternion const*)quaternion0)->operator==((Dali::Quaternion const&)*quaternion1); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void* nuiRotation0, void* nuiRotation1) +{ + bool result; + Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; + Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; + + if(!quaternion1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + { + try + { + result = (bool)((Dali::Quaternion const*)quaternion0)->operator!=((Dali::Quaternion const&)*quaternion1); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void* nuiRotation) +{ + float result; + Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; + + { + try + { + result = (float)((Dali::Quaternion const*)quaternion)->Length(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void* nuiRotation) +{ + float result; + Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; + + { + try + { + result = (float)((Dali::Quaternion const*)quaternion)->LengthSquared(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void* nuiRotation) +{ + Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; + + { + try + { + (quaternion)->Normalize(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void* nuiRotation) +{ + void* jresult; + Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; + Dali::Quaternion result; + + { + try + { + result = ((Dali::Quaternion const*)quaternion)->Normalized(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Quaternion((const Dali::Quaternion&)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void* nuiRotation) +{ + Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; + + { + try + { + (quaternion)->Conjugate(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void* nuiRotation) +{ + Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; + + { + try + { + (quaternion)->Invert(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Log(void* nuiRotation) +{ + void* jresult; + Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; + Dali::Quaternion result; + + { + try + { + result = ((Dali::Quaternion const*)quaternion)->Log(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Quaternion((const Dali::Quaternion&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Exp(void* nuiRotation) +{ + void* jresult; + Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; + Dali::Quaternion result; + + { + try + { + result = ((Dali::Quaternion const*)quaternion)->Exp(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Quaternion((const Dali::Quaternion&)result); + return jresult; +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void* nuiRotation0, void* nuiRotation1) +{ + float result; + Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; + Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; + + if(!quaternion0) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + if(!quaternion1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + { + try + { + result = (float)Dali::Quaternion::Dot((Dali::Quaternion const&)*quaternion0, (Dali::Quaternion const&)*quaternion1); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void* nuiRotation0, void* nuiRotation1, float progress) +{ + void* jresult; + Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; + Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; + Dali::Quaternion result; + + if(!quaternion0) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + if(!quaternion1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + + { + try + { + result = Dali::Quaternion::Lerp((Dali::Quaternion const&)*quaternion0, (Dali::Quaternion const&)*quaternion1, progress); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Quaternion((const Dali::Quaternion&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void* nuiRotation0, void* nuiRotation1, float progress) +{ + void* jresult; + Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; + Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; + Dali::Quaternion result; + + if(!quaternion0) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + if(!quaternion1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + + { + try + { + result = Dali::Quaternion::Slerp((Dali::Quaternion const&)*quaternion0, (Dali::Quaternion const&)*quaternion1, progress); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Quaternion((const Dali::Quaternion&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void* nuiRotation0, void* nuiRotation1, float progress) +{ + void* jresult; + Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; + Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; + Dali::Quaternion result; + + if(!quaternion0) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + if(!quaternion1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + + { + try + { + result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const&)*quaternion0, (Dali::Quaternion const&)*quaternion1, progress); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Quaternion((const Dali::Quaternion&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Squad(void* nuiStart, void* nuiEnd, void* nuiControl0, void* nuiControl1, float progress) +{ + void* jresult; + Dali::Quaternion* start = (Dali::Quaternion*)nuiStart; + Dali::Quaternion* end = (Dali::Quaternion*)nuiEnd; + Dali::Quaternion* control0 = (Dali::Quaternion*)nuiControl0; + Dali::Quaternion* control1 = (Dali::Quaternion*)nuiControl1; + Dali::Quaternion result; + + if(!start) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + if(!end) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + if(!control0) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + if(!control1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + { + try + { + result = Dali::Quaternion::Squad((Dali::Quaternion const&)*start, (Dali::Quaternion const&)*end, (Dali::Quaternion const&)*control0, (Dali::Quaternion const&)*control1, progress); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Quaternion((const Dali::Quaternion&)result); + return jresult; +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void* nuiRotation0, void* nuiRotation1) +{ + float result; + Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; + Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; + + if(!quaternion0) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + if(!quaternion1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + { + try + { + result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const&)*quaternion0, (Dali::Quaternion const&)*quaternion1); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Rotate_Vector3(void* nuiRotation, void* nuiVector3) +{ + void* jresult; + Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; + Dali::Vector3* vector3 = (Dali::Vector3*)nuiVector3; + Dali::Vector3 result; + + if(!quaternion) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + if(!vector3) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + { + try + { + result = ((Dali::Quaternion const*)quaternion)->Rotate(*vector3); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3&)result); + return jresult; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Rotate_Vector4(void* nuiRotation, void* nuiVector4) +{ + void* jresult; + Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; + Dali::Vector4* vector4 = (Dali::Vector4*)nuiVector4; + Dali::Vector4 result; + + if(!quaternion) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + if(!vector4) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + { + try + { + result = ((Dali::Quaternion const*)quaternion)->Rotate(*vector4); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4&)result); + return jresult; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-core/vector-wrap.cpp b/dali-csharp-binder/dali-core/vector-wrap.cpp new file mode 100644 index 00000000..a066fd11 --- /dev/null +++ b/dali-csharp-binder/dali-core/vector-wrap.cpp @@ -0,0 +1,3054 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +using namespace Dali; + +#ifdef __cplusplus +extern "C" { +#endif + + +// Method + +// Vector2 + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() { + void * jresult ; + Dali::Vector2 *result = 0 ; + + { + try { + result = (Dali::Vector2 *)new Dali::Vector2(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) { + void * jresult ; + float arg1 ; + float arg2 ; + Dali::Vector2 *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + { + try { + result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) { + void * jresult ; + float *arg1 = (float *) 0 ; + Dali::Vector2 *result = 0 ; + + arg1 = jarg1; + { + try { + result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) { + void * jresult ; + Dali::Vector3 *arg1 = 0 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) { + void * jresult ; + Dali::Vector4 *arg1 = 0 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::Vector4 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() { + void * jresult ; + Dali::Vector2 *result = 0 ; + + result = (Dali::Vector2 *)&Dali::Vector2::ONE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() { + void * jresult ; + Dali::Vector2 *result = 0 ; + + result = (Dali::Vector2 *)&Dali::Vector2::XAXIS; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() { + void * jresult ; + Dali::Vector2 *result = 0 ; + + result = (Dali::Vector2 *)&Dali::Vector2::YAXIS; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() { + void * jresult ; + Dali::Vector2 *result = 0 ; + + result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() { + void * jresult ; + Dali::Vector2 *result = 0 ; + + result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() { + void * jresult ; + Dali::Vector2 *result = 0 ; + + result = (Dali::Vector2 *)&Dali::Vector2::ZERO; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) { + void * jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + float *arg2 = (float *) 0 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = jarg2; + { + try { + result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + Dali::Vector4 *arg2 = 0 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + Dali::Vector2 *arg2 = 0 ; + Dali::Vector2 result; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + Dali::Vector2 *arg2 = 0 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + Dali::Vector2 *arg2 = 0 ; + Dali::Vector2 result; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + Dali::Vector2 *arg2 = 0 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + Dali::Vector2 *arg2 = 0 ; + Dali::Vector2 result; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) { + void * jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + float arg2 ; + Dali::Vector2 result; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (float)jarg2; + { + try { + result = ((Dali::Vector2 const *)arg1)->operator *(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + Dali::Vector2 *arg2 = 0 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) { + void * jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + float arg2 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (Dali::Vector2 *) &(arg1)->operator *=(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + Dali::Vector2 *arg2 = 0 ; + Dali::Vector2 result; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) { + void * jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + float arg2 ; + Dali::Vector2 result; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (float)jarg2; + { + try { + result = ((Dali::Vector2 const *)arg1)->operator /(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + Dali::Vector2 *arg2 = 0 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) { + void * jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + float arg2 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (Dali::Vector2 *) &(arg1)->operator /=(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::Vector2 *)jarg1; + { + try { + result = ((Dali::Vector2 const *)arg1)->operator -(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + Dali::Vector2 *arg2 = 0 ; + bool result; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + Dali::Vector2 *arg2 = 0 ; + bool result; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) { + float jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + unsigned int arg2 ; + float *result = 0 ; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = *result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) { + float jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + float result; + + arg1 = (Dali::Vector2 *)jarg1; + { + try { + result = (float)((Dali::Vector2 const *)arg1)->Length(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) { + float jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + float result; + + arg1 = (Dali::Vector2 *)jarg1; + { + try { + result = (float)((Dali::Vector2 const *)arg1)->LengthSquared(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) { + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + + arg1 = (Dali::Vector2 *)jarg1; + { + try { + (arg1)->Normalize(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) { + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + Dali::Vector2 *arg2 = 0 ; + Dali::Vector2 *arg3 = 0 ; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + arg3 = (Dali::Vector2 *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + { + try { + (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) { + void * jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + float *result = 0 ; + + arg1 = (Dali::Vector2 *)jarg1; + { + try { + result = (float *)((Dali::Vector2 const *)arg1)->AsFloat(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) { + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->x = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) { + float jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + float result; + + arg1 = (Dali::Vector2 *)jarg1; + result = (float) ((arg1)->x); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) { + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->width = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) { + float jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + float result; + + arg1 = (Dali::Vector2 *)jarg1; + result = (float) ((arg1)->width); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) { + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->y = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) { + float jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + float result; + + arg1 = (Dali::Vector2 *)jarg1; + result = (float) ((arg1)->y); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) { + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector2 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->height = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) { + float jresult ; + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + float result; + + arg1 = (Dali::Vector2 *)jarg1; + result = (float) ((arg1)->height); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) { + Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; + + arg1 = (Dali::Vector2 *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector2 *arg1 = 0 ; + Dali::Vector2 *arg2 = 0 ; + Dali::Vector2 result; + + arg1 = (Dali::Vector2 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector2 *arg1 = 0 ; + Dali::Vector2 *arg2 = 0 ; + Dali::Vector2 result; + + arg1 = (Dali::Vector2 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) { + void * jresult ; + Dali::Vector2 *arg1 = 0 ; + float *arg2 = 0 ; + float *arg3 = 0 ; + float temp2 ; + float temp3 ; + Dali::Vector2 result; + + arg1 = (Dali::Vector2 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + temp2 = (float)jarg2; + arg2 = &temp2; + temp3 = (float)jarg3; + arg3 = &temp3; + { + try { + result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +// Vector3 + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + { + try { + result = (Dali::Vector3 *)new Dali::Vector3(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) { + void * jresult ; + float arg1 ; + float arg2 ; + float arg3 ; + Dali::Vector3 *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + { + try { + result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) { + void * jresult ; + float *arg1 = (float *) 0 ; + Dali::Vector3 *result = 0 ; + + arg1 = jarg1; + { + try { + result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) { + void * jresult ; + Dali::Vector2 *arg1 = 0 ; + Dali::Vector3 *result = 0 ; + + arg1 = (Dali::Vector2 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) { + void * jresult ; + Dali::Vector4 *arg1 = 0 ; + Dali::Vector3 *result = 0 ; + + arg1 = (Dali::Vector4 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::Vector3::ONE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::Vector3::XAXIS; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::Vector3::YAXIS; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() { + void * jresult ; + Dali::Vector3 *result = 0 ; + + result = (Dali::Vector3 *)&Dali::Vector3::ZERO; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float *arg2 = (float *) 0 ; + Dali::Vector3 *result = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = jarg2; + { + try { + result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + Dali::Vector2 *arg2 = 0 ; + Dali::Vector3 *result = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + Dali::Vector4 *arg2 = 0 ; + Dali::Vector3 *result = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Vector3 result; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Vector3 *result = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Vector3 result; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Vector3 *result = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Vector3 result; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float arg2 ; + Dali::Vector3 result; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (float)jarg2; + { + try { + result = ((Dali::Vector3 const *)arg1)->operator *(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Vector3 *result = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float arg2 ; + Dali::Vector3 *result = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (Dali::Vector3 *) &(arg1)->operator *=(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + Dali::Quaternion *arg2 = 0 ; + Dali::Vector3 *result = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (Dali::Quaternion *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Vector3 result; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float arg2 ; + Dali::Vector3 result; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (float)jarg2; + { + try { + result = ((Dali::Vector3 const *)arg1)->operator /(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Vector3 *result = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float arg2 ; + Dali::Vector3 *result = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (Dali::Vector3 *) &(arg1)->operator /=(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + Dali::Vector3 result; + + arg1 = (Dali::Vector3 *)jarg1; + { + try { + result = ((Dali::Vector3 const *)arg1)->operator -(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + Dali::Vector3 *arg2 = 0 ; + bool result; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + Dali::Vector3 *arg2 = 0 ; + bool result; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) { + float jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + unsigned int arg2 ; + float *result = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = *result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) { + float jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + Dali::Vector3 *arg2 = 0 ; + float result; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Vector3 result; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) { + float jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float result; + + arg1 = (Dali::Vector3 *)jarg1; + { + try { + result = (float)((Dali::Vector3 const *)arg1)->Length(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) { + float jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float result; + + arg1 = (Dali::Vector3 *)jarg1; + { + try { + result = (float)((Dali::Vector3 const *)arg1)->LengthSquared(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) { + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + { + try { + (arg1)->Normalize(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) { + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Vector3 *arg3 = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + arg3 = (Dali::Vector3 *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + { + try { + (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float *result = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + { + try { + result = (float *)((Dali::Vector3 const *)arg1)->AsFloat(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + { + try { + result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) { + void * jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + { + try { + result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) { + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->x = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) { + float jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float result; + + arg1 = (Dali::Vector3 *)jarg1; + result = (float) ((arg1)->x); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) { + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->width = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) { + float jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float result; + + arg1 = (Dali::Vector3 *)jarg1; + result = (float) ((arg1)->width); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) { + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->r = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) { + float jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float result; + + arg1 = (Dali::Vector3 *)jarg1; + result = (float) ((arg1)->r); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) { + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->y = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) { + float jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float result; + + arg1 = (Dali::Vector3 *)jarg1; + result = (float) ((arg1)->y); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) { + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->height = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) { + float jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float result; + + arg1 = (Dali::Vector3 *)jarg1; + result = (float) ((arg1)->height); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) { + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->g = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) { + float jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float result; + + arg1 = (Dali::Vector3 *)jarg1; + result = (float) ((arg1)->g); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) { + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->z = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) { + float jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float result; + + arg1 = (Dali::Vector3 *)jarg1; + result = (float) ((arg1)->z); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) { + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->depth = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) { + float jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float result; + + arg1 = (Dali::Vector3 *)jarg1; + result = (float) ((arg1)->depth); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) { + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector3 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->b = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) { + float jresult ; + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + float result; + + arg1 = (Dali::Vector3 *)jarg1; + result = (float) ((arg1)->b); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) { + Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector3 *arg1 = 0 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Vector3 result; + + arg1 = (Dali::Vector3 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector3 *arg1 = 0 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Vector3 result; + + arg1 = (Dali::Vector3 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) { + void * jresult ; + Dali::Vector3 *arg1 = 0 ; + float *arg2 = 0 ; + float *arg3 = 0 ; + float temp2 ; + float temp3 ; + Dali::Vector3 result; + + arg1 = (Dali::Vector3 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + temp2 = (float)jarg2; + arg2 = &temp2; + temp3 = (float)jarg3; + arg3 = &temp3; + { + try { + result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +// Vector4 + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() { + void * jresult ; + Dali::Vector4 *result = 0 ; + + { + try { + result = (Dali::Vector4 *)new Dali::Vector4(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) { + void * jresult ; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + Dali::Vector4 *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + { + try { + result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) { + void * jresult ; + float *arg1 = (float *) 0 ; + Dali::Vector4 *result = 0 ; + + arg1 = jarg1; + { + try { + result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) { + void * jresult ; + Dali::Vector2 *arg1 = 0 ; + Dali::Vector4 *result = 0 ; + + arg1 = (Dali::Vector2 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) { + void * jresult ; + Dali::Vector3 *arg1 = 0 ; + Dali::Vector4 *result = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() { + void * jresult ; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Vector4::ONE; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() { + void * jresult ; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Vector4::XAXIS; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() { + void * jresult ; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Vector4::YAXIS; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() { + void * jresult ; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() { + void * jresult ; + Dali::Vector4 *result = 0 ; + + result = (Dali::Vector4 *)&Dali::Vector4::ZERO; + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) { + void * jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float *arg2 = (float *) 0 ; + Dali::Vector4 *result = 0 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = jarg2; + { + try { + result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + Dali::Vector2 *arg2 = 0 ; + Dali::Vector4 *result = 0 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Vector4 *result = 0 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + Dali::Vector4 *arg2 = 0 ; + Dali::Vector4 result; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + Dali::Vector4 *arg2 = 0 ; + Dali::Vector4 *result = 0 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + Dali::Vector4 *arg2 = 0 ; + Dali::Vector4 result; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + Dali::Vector4 *arg2 = 0 ; + Dali::Vector4 *result = 0 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + Dali::Vector4 *arg2 = 0 ; + Dali::Vector4 result; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) { + void * jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float arg2 ; + Dali::Vector4 result; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (float)jarg2; + { + try { + result = ((Dali::Vector4 const *)arg1)->operator *(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + Dali::Vector4 *arg2 = 0 ; + Dali::Vector4 *result = 0 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) { + void * jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float arg2 ; + Dali::Vector4 *result = 0 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (Dali::Vector4 *) &(arg1)->operator *=(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + Dali::Vector4 *arg2 = 0 ; + Dali::Vector4 result; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) { + void * jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float arg2 ; + Dali::Vector4 result; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (float)jarg2; + { + try { + result = ((Dali::Vector4 const *)arg1)->operator /(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + Dali::Vector4 *arg2 = 0 ; + Dali::Vector4 *result = 0 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) { + void * jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float arg2 ; + Dali::Vector4 *result = 0 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (Dali::Vector4 *) &(arg1)->operator /=(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + Dali::Vector4 result; + + arg1 = (Dali::Vector4 *)jarg1; + { + try { + result = ((Dali::Vector4 const *)arg1)->operator -(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + Dali::Vector4 *arg2 = 0 ; + bool result; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + Dali::Vector4 *arg2 = 0 ; + bool result; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) { + float jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + unsigned int arg2 ; + float *result = 0 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = *result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) { + float jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + Dali::Vector3 *arg2 = 0 ; + float result; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) { + float jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + Dali::Vector4 *arg2 = 0 ; + float result; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) { + float jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + Dali::Vector4 *arg2 = 0 ; + float result; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + Dali::Vector4 *arg2 = 0 ; + Dali::Vector4 result; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) { + float jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float result; + + arg1 = (Dali::Vector4 *)jarg1; + { + try { + result = (float)((Dali::Vector4 const *)arg1)->Length(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) { + float jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float result; + + arg1 = (Dali::Vector4 *)jarg1; + { + try { + result = (float)((Dali::Vector4 const *)arg1)->LengthSquared(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) { + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + + arg1 = (Dali::Vector4 *)jarg1; + { + try { + (arg1)->Normalize(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) { + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + Dali::Vector4 *arg2 = 0 ; + Dali::Vector4 *arg3 = 0 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return ; + } + arg3 = (Dali::Vector4 *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return ; + } + { + try { + (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) { + void * jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float *result = 0 ; + + arg1 = (Dali::Vector4 *)jarg1; + { + try { + result = (float *)((Dali::Vector4 const *)arg1)->AsFloat(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) { + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->x = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) { + float jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float result; + + arg1 = (Dali::Vector4 *)jarg1; + result = (float) ((arg1)->x); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) { + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->r = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) { + float jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float result; + + arg1 = (Dali::Vector4 *)jarg1; + result = (float) ((arg1)->r); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) { + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->s = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) { + float jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float result; + + arg1 = (Dali::Vector4 *)jarg1; + result = (float) ((arg1)->s); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) { + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->y = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) { + float jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float result; + + arg1 = (Dali::Vector4 *)jarg1; + result = (float) ((arg1)->y); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) { + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->g = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) { + float jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float result; + + arg1 = (Dali::Vector4 *)jarg1; + result = (float) ((arg1)->g); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) { + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->t = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) { + float jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float result; + + arg1 = (Dali::Vector4 *)jarg1; + result = (float) ((arg1)->t); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) { + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->z = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) { + float jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float result; + + arg1 = (Dali::Vector4 *)jarg1; + result = (float) ((arg1)->z); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) { + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->b = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) { + float jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float result; + + arg1 = (Dali::Vector4 *)jarg1; + result = (float) ((arg1)->b); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) { + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->p = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) { + float jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float result; + + arg1 = (Dali::Vector4 *)jarg1; + result = (float) ((arg1)->p); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) { + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->w = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) { + float jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float result; + + arg1 = (Dali::Vector4 *)jarg1; + result = (float) ((arg1)->w); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) { + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->a = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) { + float jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float result; + + arg1 = (Dali::Vector4 *)jarg1; + result = (float) ((arg1)->a); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) { + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float arg2 ; + + arg1 = (Dali::Vector4 *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->q = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) { + float jresult ; + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + float result; + + arg1 = (Dali::Vector4 *)jarg1; + result = (float) ((arg1)->q); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) { + Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; + + arg1 = (Dali::Vector4 *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector4 *arg1 = 0 ; + Dali::Vector4 *arg2 = 0 ; + Dali::Vector4 result; + + arg1 = (Dali::Vector4 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Vector4 *arg1 = 0 ; + Dali::Vector4 *arg2 = 0 ; + Dali::Vector4 result; + + arg1 = (Dali::Vector4 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + { + try { + result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) { + void * jresult ; + Dali::Vector4 *arg1 = 0 ; + float *arg2 = 0 ; + float *arg3 = 0 ; + float temp2 ; + float temp3 ; + Dali::Vector4 result; + + arg1 = (Dali::Vector4 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return 0; + } + temp2 = (float)jarg2; + arg2 = &temp2; + temp3 = (float)jarg3; + arg3 = &temp3; + { + try { + result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + + +// Signals + + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-extension/rive-animation-view-wrap.cpp b/dali-csharp-binder/dali-extension/rive-animation-view-wrap.cpp new file mode 100644 index 00000000..0828425b --- /dev/null +++ b/dali-csharp-binder/dali-extension/rive-animation-view-wrap.cpp @@ -0,0 +1,424 @@ +/* + * Copyright (c) 2021 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +using namespace Dali; +using namespace Dali::Toolkit; +using namespace Dali::Extension; + +#ifdef __cplusplus +extern "C" { +#endif + +static const char *nullExceptMsg = "Attempt to dereference null Dali::Extension::RiveAnimationView"; + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_RiveAnimationView_New__SWIG_0(char * jarg1) { + void *jresult = nullptr; + RiveAnimationView result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + { + try { + result = RiveAnimationView::New(arg1_str); + jresult = new Dali::Extension::RiveAnimationView((const Dali::Extension::RiveAnimationView &)result); + } CALL_CATCH_EXCEPTION(0); + } + + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RiveAnimationView_EnableAnimation(char * jarg1, char * jarg2, bool jarg3) { + RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; + + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); + return; + } + std::string arg2_str(jarg2); + { + try { + arg1->EnableAnimation(arg2_str, jarg3); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RiveAnimationView_PlayAnimation(char * jarg1) { + RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; + + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return; + } + { + try { + arg1->PlayAnimation(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RiveAnimationView_PauseAnimation(char * jarg1) { + RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; + + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return; + } + { + try { + arg1->PauseAnimation(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RiveAnimationView_StopAnimation(char * jarg1) { + RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; + + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return; + } + { + try { + arg1->StopAnimation(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void CSharp_Dali_RiveAnimationView_SetShapeFillColor(char * jarg1, char * jarg2, char * jarg3) +{ + Dali::Vector4 *arg3 = nullptr; + + RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); + return; + } + std::string arg2_str(jarg2); + arg3 = (Dali::Vector4 *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return; + } + arg3->a *= 255.f; + arg3->r *= 255.f; + arg3->g *= 255.f; + arg3->b *= 255.f; + { + try { + arg1->SetShapeFillColor(arg2_str, *arg3); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void CSharp_Dali_RiveAnimationView_SetShapeStrokeColor(char * jarg1, char * jarg2, char * jarg3) +{ + Dali::Vector4 *arg3 = nullptr; + + RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); + return; + } + std::string arg2_str(jarg2); + arg3 = (Dali::Vector4 *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return; + } + arg3->a *= 255.f; + arg3->r *= 255.f; + arg3->g *= 255.f; + arg3->b *= 255.f; + { + try { + arg1->SetShapeStrokeColor(arg2_str, *arg3); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void CSharp_Dali_RiveAnimationView_SetNodeOpacity(char * jarg1, char * jarg2, float jarg3) +{ + RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; + + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); + return; + } + std::string arg2_str(jarg2); + { + try { + arg1->SetNodeOpacity(arg2_str, jarg3); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void CSharp_Dali_RiveAnimationView_SetNodeScale(char * jarg1, char * jarg2, char * jarg3) +{ + Dali::Vector2 *arg3 = nullptr; + + RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); + return; + } + std::string arg2_str(jarg2); + arg3 = (Dali::Vector2 *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return; + } + { + try { + arg1->SetNodeScale(arg2_str, *arg3); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void CSharp_Dali_RiveAnimationView_SetNodeRotation(char * jarg1, char * jarg2, char * jarg3) +{ + Dali::Degree *arg3 = nullptr; + + RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); + return; + } + std::string arg2_str(jarg2); + arg3 = (Dali::Degree *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0); + return; + } + { + try { + arg1->SetNodeRotation(arg2_str, *arg3); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void CSharp_Dali_RiveAnimationView_SetNodePosition(char * jarg1, char * jarg2, char * jarg3) +{ + Dali::Vector2 *arg3 = nullptr; + + RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); + return; + } + std::string arg2_str(jarg2); + arg3 = (Dali::Vector2 *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return; + } + { + try { + arg1->SetNodePosition(arg2_str, *arg3); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void CSharp_Dali_RiveAnimationView_PointerMove(char * jarg1, float jarg2, float jarg3) +{ + RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return; + } + { + try { + arg1->PointerMove(jarg2, jarg3); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void CSharp_Dali_RiveAnimationView_PointerDown(char * jarg1, float jarg2, float jarg3) +{ + RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return; + } + { + try { + arg1->PointerDown(jarg2, jarg3); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void CSharp_Dali_RiveAnimationView_PointerUp(char * jarg1, float jarg2, float jarg3) +{ + RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return; + } + { + try { + arg1->PointerUp(jarg2, jarg3); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool CSharp_Dali_RiveAnimationView_SetNumberState(char * jarg1, char * jarg2, char * jarg3, float jarg4) +{ + RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return false; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); + return false; + } + std::string arg2_str(jarg2); + if (!jarg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg3 is null string", 0); + return false; + } + std::string arg3_str(jarg3); + { + try { + return arg1->SetNumberState(arg2_str, arg3_str, jarg4); + } + CALL_CATCH_EXCEPTION(false); + } +} + +SWIGEXPORT bool CSharp_Dali_RiveAnimationView_SetBooleanState(char * jarg1, char * jarg2, char * jarg3, bool jarg4) +{ + RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return false; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); + return false; + } + std::string arg2_str(jarg2); + if (!jarg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg3 is null string", 0); + return false; + } + std::string arg3_str(jarg3); + { + try { + return arg1->SetBooleanState(arg2_str, arg3_str, jarg4); + } + CALL_CATCH_EXCEPTION(false); + } +} + +SWIGEXPORT bool CSharp_Dali_RiveAnimationView_FireState(char * jarg1, char * jarg2, char * jarg3) +{ + RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return false; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); + return false; + } + std::string arg2_str(jarg2); + if (!jarg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg3 is null string", 0); + return false; + } + std::string arg3_str(jarg3); + { + try { + return arg1->FireState(arg2_str, arg3_str); + } + CALL_CATCH_EXCEPTION(false); + } +} + +SWIGEXPORT void CSharp_Dali_RiveAnimationView_SetAnimationElapsedTime(char * jarg1, char * jarg2, float jarg3) +{ + RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); + return; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); + return; + } + std::string arg2_str(jarg2); + { + try { + arg1->SetAnimationElapsedTime(arg2_str, jarg3); + } + CALL_CATCH_EXCEPTION(); + } +} + +#ifdef __cplusplus +} // end extern "C" +#endif diff --git a/dali-csharp-binder/dali-scene3d/light-wrap.cpp b/dali-csharp-binder/dali-scene3d/light-wrap.cpp new file mode 100644 index 00000000..68f156f1 --- /dev/null +++ b/dali-csharp-binder/dali-scene3d/light-wrap.cpp @@ -0,0 +1,184 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Light_New_SWIG_0() +{ + Dali::Scene3D::Light result; + + { + try + { + result = Dali::Scene3D::Light::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::Light((const Dali::Scene3D::Light&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Light_SWIG_0() +{ + Dali::Scene3D::Light* result = 0; + + { + try + { + result = (Dali::Scene3D::Light*)new Dali::Scene3D::Light(); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Light_SWIG_1(void* csLight) +{ + Dali::Scene3D::Light* light = (Dali::Scene3D::Light*)csLight; + Dali::Scene3D::Light* result = 0; + + if(!light) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::Light const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::Light*)new Dali::Scene3D::Light((Dali::Scene3D::Light const&)*light); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Light(void* csLight) +{ + Dali::Scene3D::Light* light = (Dali::Scene3D::Light*)csLight; + { + try + { + delete light; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Light_Assign(void* csDestination, void* csSource) +{ + Dali::Scene3D::Light* destination = (Dali::Scene3D::Light*)csDestination; + Dali::Scene3D::Light* source = (Dali::Scene3D::Light*)csSource; + Dali::Scene3D::Light* result = 0; + + if(!source) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::Light const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::Light*)&(destination)->operator=((Dali::Scene3D::Light const&)*source); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Light_DownCast(void* csHandle) +{ + Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; + Dali::Scene3D::Light result; + + if(!handle) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Light", 0); + return 0; + } + { + try + { + result = Dali::Scene3D::Light::DownCast(*handle); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::Light((const Dali::Scene3D::Light&)result); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Light_Enable(void* csLight, bool enable) +{ + Dali::Scene3D::Light* light = (Dali::Scene3D::Light*)csLight; + + if(!light) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Light", 0); + return; + } + + try + { + light->Enable(enable); + } + CALL_CATCH_EXCEPTION(); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Light_IsEnabled(void* csLight) +{ + Dali::Scene3D::Light* light = (Dali::Scene3D::Light*)csLight; + bool result; + + if(!light) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Light", 0); + return false; + } + + try + { + result = light->IsEnabled(); + } + CALL_CATCH_EXCEPTION(0); + + return result; +} + +SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_SceneView_GetMaximumEnabledLightCount() +{ + uint32_t result = 0u; + try + { + result = static_cast(Dali::Scene3D::Light::GetMaximumEnabledLightCount()); + } + CALL_CATCH_EXCEPTION(0); + return result; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-scene3d/material-wrap.cpp b/dali-csharp-binder/dali-scene3d/material-wrap.cpp new file mode 100644 index 00000000..26eed5cc --- /dev/null +++ b/dali-csharp-binder/dali-scene3d/material-wrap.cpp @@ -0,0 +1,358 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Material_New_SWIG_0() +{ + Dali::Scene3D::Material result; + + { + try + { + result = Dali::Scene3D::Material::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::Material((const Dali::Scene3D::Material&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Material_SWIG_0() +{ + Dali::Scene3D::Material* result = 0; + + { + try + { + result = (Dali::Scene3D::Material*)new Dali::Scene3D::Material(); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Material_SWIG_1(void* csModel) +{ + Dali::Scene3D::Material* model = (Dali::Scene3D::Material*)csModel; + Dali::Scene3D::Material* result = 0; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::Material const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::Material*)new Dali::Scene3D::Material((Dali::Scene3D::Material const&)*model); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Material(void* csModel) +{ + Dali::Scene3D::Material* model = (Dali::Scene3D::Material*)csModel; + { + try + { + delete model; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Material_Assign(void* csDestination, void* csSource) +{ + Dali::Scene3D::Material* destination = (Dali::Scene3D::Material*)csDestination; + Dali::Scene3D::Material* source = (Dali::Scene3D::Material*)csSource; + Dali::Scene3D::Material* result = 0; + + if(!source) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::Material const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::Material*)&(destination)->operator=((Dali::Scene3D::Material const&)*source); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Material_DownCast(void* csHandle) +{ + Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; + Dali::Scene3D::Material result; + + if(!handle) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Material", 0); + return 0; + } + { + try + { + result = Dali::Scene3D::Material::DownCast(*handle); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::Material((const Dali::Scene3D::Material&)result); +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_NAME_get() +{ + return (int)Dali::Scene3D::Material::Property::NAME; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_BASE_COLOR_URL_get() +{ + return (int)Dali::Scene3D::Material::Property::BASE_COLOR_URL; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_BASE_COLOR_FACTOR_get() +{ + return (int)Dali::Scene3D::Material::Property::BASE_COLOR_FACTOR; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_METALLIC_ROUGHNESS_URL_get() +{ + return (int)Dali::Scene3D::Material::Property::METALLIC_ROUGHNESS_URL; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_METALLIC_FACTOR_get() +{ + return (int)Dali::Scene3D::Material::Property::METALLIC_FACTOR; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_ROUGHNESS_FACTOR_get() +{ + return (int)Dali::Scene3D::Material::Property::ROUGHNESS_FACTOR; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_NORMAL_URL_get() +{ + return (int)Dali::Scene3D::Material::Property::NORMAL_URL; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_NORMAL_SCALE_get() +{ + return (int)Dali::Scene3D::Material::Property::NORMAL_SCALE; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_OCCLUSION_URL_get() +{ + return (int)Dali::Scene3D::Material::Property::OCCLUSION_URL; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_OCCLUSION_STRENGTH_get() +{ + return (int)Dali::Scene3D::Material::Property::OCCLUSION_STRENGTH; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_EMISSIVE_URL_get() +{ + return (int)Dali::Scene3D::Material::Property::EMISSIVE_URL; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_EMISSIVE_FACTOR_get() +{ + return (int)Dali::Scene3D::Material::Property::EMISSIVE_FACTOR; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_ALPHA_MODE_get() +{ + return (int)Dali::Scene3D::Material::Property::ALPHA_MODE; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_ALPHA_CUTOFF_get() +{ + return (int)Dali::Scene3D::Material::Property::ALPHA_CUTOFF; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_DOUBLE_SIDED_get() +{ + return (int)Dali::Scene3D::Material::Property::DOUBLE_SIDED; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_IOR_get() +{ + return (int)Dali::Scene3D::Material::Property::IOR; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_SPECULAR_URL_get() +{ + return (int)Dali::Scene3D::Material::Property::SPECULAR_URL; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_SPECULAR_FACTOR_get() +{ + return (int)Dali::Scene3D::Material::Property::SPECULAR_FACTOR; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_SPECULAR_COLOR_URL_get() +{ + return (int)Dali::Scene3D::Material::Property::SPECULAR_COLOR_URL; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_SPECULAR_COLOR_FACTOR_get() +{ + return (int)Dali::Scene3D::Material::Property::SPECULAR_COLOR_FACTOR; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Material_SetProperty(void* csMaterial, int index, void* csPropertyValue) +{ + Dali::Scene3D::Material* material = (Dali::Scene3D::Material*)csMaterial; + Dali::Property::Value* propertyValue = (Dali::Property::Value*)csPropertyValue; + + if(!material) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Material", 0); + return; + } + { + try + { + material->SetProperty((Dali::Property::Index)index, *propertyValue); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Material_GetProperty(void* csMaterial, int index) +{ + Dali::Scene3D::Material* material = (Dali::Scene3D::Material*)csMaterial; + Dali::Property::Value result; + + if(!material) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Material", 0); + return nullptr; + } + { + try + { + result = material->GetProperty((Dali::Property::Index)index); + } + CALL_CATCH_EXCEPTION(nullptr); + } + return new Dali::Property::Value((const Dali::Property::Value&)result); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Material_SetTexture(void* csMaterial, unsigned int index, void* csTexture) +{ + Dali::Scene3D::Material* material = (Dali::Scene3D::Material*)csMaterial; + Dali::Texture* texture = (Dali::Texture*)csTexture; + + if(!material) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Material", 0); + return; + } + + if(!texture) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0); + return; + } + + try + { + material->SetTexture((Dali::Scene3D::Material::TextureType)index, *texture); + } + CALL_CATCH_EXCEPTION(); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Material_GetTexture(void* csMaterial, unsigned int index) +{ + Dali::Scene3D::Material* material = (Dali::Scene3D::Material*)csMaterial; + Dali::Texture result; + + if(!material) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Material", 0); + return nullptr; + } + + try + { + result = material->GetTexture((Dali::Scene3D::Material::TextureType)index); + } + CALL_CATCH_EXCEPTION(nullptr); + + return new Dali::Texture((const Dali::Texture&)result); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Material_SetSampler(void* csMaterial, unsigned int index, void* csSampler) +{ + Dali::Scene3D::Material* material = (Dali::Scene3D::Material*)csMaterial; + Dali::Sampler* sampler = (Dali::Sampler*)csSampler; + + if(!material) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Material", 0); + return; + } + + try + { + material->SetSampler((Dali::Scene3D::Material::TextureType)index, *sampler); + } + CALL_CATCH_EXCEPTION(); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Material_GetSampler(void* csMaterial, unsigned int index) +{ + Dali::Scene3D::Material* material = (Dali::Scene3D::Material*)csMaterial; + Dali::Sampler result; + + if(!material) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Material", 0); + return nullptr; + } + + try + { + result = material->GetSampler((Dali::Scene3D::Material::TextureType)index); + } + CALL_CATCH_EXCEPTION(nullptr); + return new Dali::Sampler((const Dali::Sampler&)result); +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-scene3d/model-node-wrap.cpp b/dali-csharp-binder/dali-scene3d/model-node-wrap.cpp new file mode 100644 index 00000000..85229182 --- /dev/null +++ b/dali-csharp-binder/dali-scene3d/model-node-wrap.cpp @@ -0,0 +1,259 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Node_New_SWIG_0() +{ + Dali::Scene3D::ModelNode result; + { + try + { + result = Dali::Scene3D::ModelNode::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::ModelNode((const Dali::Scene3D::ModelNode&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Model_Node_SWIG_0() +{ + Dali::Scene3D::ModelNode* result = 0; + + { + try + { + result = (Dali::Scene3D::ModelNode*)new Dali::Scene3D::ModelNode(); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Model_Node_SWIG_1(void* csModel) +{ + Dali::Scene3D::ModelNode* model = (Dali::Scene3D::ModelNode*)csModel; + Dali::Scene3D::ModelNode* result = 0; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::ModelNode const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::ModelNode*)new Dali::Scene3D::ModelNode((Dali::Scene3D::ModelNode const&)*model); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model_Node(void* csModel) +{ + Dali::Scene3D::ModelNode* model = (Dali::Scene3D::ModelNode*)csModel; + { + try + { + delete model; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Node_Assign(void* csDestination, void* csSource) +{ + Dali::Scene3D::ModelNode* destination = (Dali::Scene3D::ModelNode*)csDestination; + Dali::Scene3D::ModelNode* source = (Dali::Scene3D::ModelNode*)csSource; + Dali::Scene3D::ModelNode* result = 0; + + if(!source) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::ModelNode const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::ModelNode*)&(destination)->operator=((Dali::Scene3D::ModelNode const&)*source); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Node_DownCast(void* csHandle) +{ + Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; + Dali::Scene3D::ModelNode result; + + if(!handle) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelNode", 0); + return 0; + } + { + try + { + result = Dali::Scene3D::ModelNode::DownCast(*handle); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::ModelNode((const Dali::Scene3D::ModelNode&)result); +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Model_Node_GetModelPrimitiveCount(void* csModelNode) +{ + Dali::Scene3D::ModelNode* modelNode = (Dali::Scene3D::ModelNode*)csModelNode; + + if(!modelNode) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelNode", 0); + return 0; + } + { + try + { + return modelNode->GetModelPrimitiveCount(); + } + CALL_CATCH_EXCEPTION(0); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_Node_AddModelPrimitive(void* csModelNode, void* csModelPrimitive) +{ + Dali::Scene3D::ModelNode* modelNode = (Dali::Scene3D::ModelNode*)csModelNode; + Dali::Scene3D::ModelPrimitive* modelPrimitive = (Dali::Scene3D::ModelPrimitive*)csModelPrimitive; + + if(!modelNode) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelNode", 0); + return; + } + if(!modelPrimitive) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelPrimitive", 0); + return; + } + { + try + { + modelNode->AddModelPrimitive(*modelPrimitive); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_Node_RemoveModelPrimitive1(void* csModelNode, void* csModelPrimitive) +{ + Dali::Scene3D::ModelNode* modelNode = (Dali::Scene3D::ModelNode*)csModelNode; + Dali::Scene3D::ModelPrimitive* modelPrimitive = (Dali::Scene3D::ModelPrimitive*)csModelPrimitive; + + if(!modelNode) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelNode", 0); + return; + } + if(!modelPrimitive) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelPrimitive", 0); + return; + } + { + try + { + modelNode->RemoveModelPrimitive(*modelPrimitive); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_Node_RemoveModelPrimitive2(void* csModelNode, unsigned int index) +{ + Dali::Scene3D::ModelNode* modelNode = (Dali::Scene3D::ModelNode*)csModelNode; + + if(!modelNode) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelNode", 0); + return; + } + { + try + { + modelNode->RemoveModelPrimitive(index); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Node_GetModelPrimitive(void* csModelNode, unsigned int index) +{ + Dali::Scene3D::ModelNode* modelNode = (Dali::Scene3D::ModelNode*)csModelNode; + Dali::Scene3D::ModelPrimitive result; + + if(!modelNode) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelNode", 0); + return nullptr; + } + { + try + { + result = modelNode->GetModelPrimitive(index); + } + CALL_CATCH_EXCEPTION(nullptr); + } + return new Dali::Scene3D::ModelPrimitive((const Dali::Scene3D::ModelPrimitive&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Node_FindChildModelNodeByName(void* csModelNode, char* nodeName) +{ + Dali::Scene3D::ModelNode* modelNode = (Dali::Scene3D::ModelNode*)csModelNode; + Dali::Scene3D::ModelNode result; + + if(!modelNode) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelNode", 0); + return nullptr; + } + { + try + { + result = modelNode->FindChildModelNodeByName(nodeName); + } + CALL_CATCH_EXCEPTION(nullptr); + } + return new Dali::Scene3D::ModelNode((const Dali::Scene3D::ModelNode&)result); +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-scene3d/model-primitive-wrap.cpp b/dali-csharp-binder/dali-scene3d/model-primitive-wrap.cpp new file mode 100644 index 00000000..d94b4924 --- /dev/null +++ b/dali-csharp-binder/dali-scene3d/model-primitive-wrap.cpp @@ -0,0 +1,194 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Primitive_New_SWIG_0() +{ + Dali::Scene3D::ModelPrimitive result; + + { + try + { + result = Dali::Scene3D::ModelPrimitive::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::ModelPrimitive((const Dali::Scene3D::ModelPrimitive&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Model_Primitive_SWIG_0() +{ + Dali::Scene3D::ModelPrimitive* result = 0; + + { + try + { + result = (Dali::Scene3D::ModelPrimitive*)new Dali::Scene3D::ModelPrimitive(); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Model_Primitive_SWIG_1(void* csModel) +{ + Dali::Scene3D::ModelPrimitive* model = (Dali::Scene3D::ModelPrimitive*)csModel; + Dali::Scene3D::ModelPrimitive* result = 0; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::ModelPrimitive const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::ModelPrimitive*)new Dali::Scene3D::ModelPrimitive((Dali::Scene3D::ModelPrimitive const&)*model); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model_Primitive(void* csModel) +{ + Dali::Scene3D::ModelPrimitive* model = (Dali::Scene3D::ModelPrimitive*)csModel; + { + try + { + delete model; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Primitive_Assign(void* csDestination, void* csSource) +{ + Dali::Scene3D::ModelPrimitive* destination = (Dali::Scene3D::ModelPrimitive*)csDestination; + Dali::Scene3D::ModelPrimitive* source = (Dali::Scene3D::ModelPrimitive*)csSource; + Dali::Scene3D::ModelPrimitive* result = 0; + + if(!source) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::ModelPrimitive const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::ModelPrimitive*)&(destination)->operator=((Dali::Scene3D::ModelPrimitive const&)*source); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Primitive_DownCast(void* csHandle) +{ + Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; + Dali::Scene3D::ModelPrimitive result; + + if(!handle) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelPrimitive", 0); + return 0; + } + { + try + { + result = Dali::Scene3D::ModelPrimitive::DownCast(*handle); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::ModelPrimitive((const Dali::Scene3D::ModelPrimitive&)result); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_Primitive_SetGeometry(void* csModelPrimitive, void* csGeometry) +{ + Dali::Scene3D::ModelPrimitive* modelPrimitive = (Dali::Scene3D::ModelPrimitive*)csModelPrimitive; + Dali::Geometry* geometry = (Dali::Geometry*)csGeometry; + + if(!modelPrimitive) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelPrimitive", 0); + return; + } + { + try + { + modelPrimitive->SetGeometry(*geometry); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Primitive_GetGeometry(void* csModelPrimitive) +{ + Dali::Scene3D::ModelPrimitive* modelPrimitive = (Dali::Scene3D::ModelPrimitive*)csModelPrimitive; + Dali::Geometry result; + + if(!modelPrimitive) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelPrimitive", 0); + return nullptr; + } + { + try + { + result = modelPrimitive->GetGeometry(); + } + CALL_CATCH_EXCEPTION(nullptr); + } + return new Dali::Geometry((const Dali::Geometry&)result); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_Primitive_SetMaterial(void* csModelPrimitive, void* csMaterial) +{ + Dali::Scene3D::ModelPrimitive* modelPrimitive = (Dali::Scene3D::ModelPrimitive*)csModelPrimitive; + Dali::Scene3D::Material* material = (Dali::Scene3D::Material*)csMaterial; + + if(!modelPrimitive) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelNode", 0); + return; + } + + try + { + modelPrimitive->SetMaterial(*material); + } + CALL_CATCH_EXCEPTION(); +} + + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-scene3d/model-wrap.cpp b/dali-csharp-binder/dali-scene3d/model-wrap.cpp new file mode 100644 index 00000000..f4d282ce --- /dev/null +++ b/dali-csharp-binder/dali-scene3d/model-wrap.cpp @@ -0,0 +1,748 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include +#include +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_New_SWIG_0(char* csModelPath, char* csResourcePath) +{ + Dali::Scene3D::Model result; + + if(!csModelPath) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string modelPath(csModelPath); + + if(!csResourcePath) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string resourcePath(csResourcePath); + + { + try + { + result = Dali::Scene3D::Model::New(modelPath, resourcePath); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::Model((const Dali::Scene3D::Model&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_New_SWIG_1() +{ + Dali::Scene3D::Model result; + + { + try + { + result = Dali::Scene3D::Model::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::Model((const Dali::Scene3D::Model&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Model_SWIG_0() +{ + Dali::Scene3D::Model* result = 0; + + { + try + { + result = (Dali::Scene3D::Model*)new Dali::Scene3D::Model(); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Model_SWIG_1(void* csModel) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + Dali::Scene3D::Model* result = 0; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::Model const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::Model*)new Dali::Scene3D::Model((Dali::Scene3D::Model const&)*model); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model(void* csModel) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + { + try + { + delete model; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Assign(void* csDestination, void* csSource) +{ + Dali::Scene3D::Model* destination = (Dali::Scene3D::Model*)csDestination; + Dali::Scene3D::Model* source = (Dali::Scene3D::Model*)csSource; + Dali::Scene3D::Model* result = 0; + + if(!source) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::Model const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::Model*)&(destination)->operator=((Dali::Scene3D::Model const&)*source); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_DownCast(void* csHandle) +{ + Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; + Dali::Scene3D::Model result; + + if(!handle) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return 0; + } + { + try + { + result = Dali::Scene3D::Model::DownCast(*handle); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::Model((const Dali::Scene3D::Model&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_GetModelRoot(void* csModel) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + Dali::Scene3D::ModelNode result; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return 0; + } + { + try + { + result = model->GetModelRoot(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::ModelNode((const Dali::Scene3D::ModelNode&)result); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_AddModelNode(void* csModel, void* csModelNode) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + Dali::Scene3D::ModelNode* modelNode = (Dali::Scene3D::ModelNode*)csModelNode; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return; + } + + try + { + model->AddModelNode(*modelNode); + } + CALL_CATCH_EXCEPTION(); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_RemoveModelNode(void* csModel, void* csModelNode) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + Dali::Scene3D::ModelNode* modelNode = (Dali::Scene3D::ModelNode*)csModelNode; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return; + } + + try + { + model->RemoveModelNode(*modelNode); + } + CALL_CATCH_EXCEPTION(); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_SetChildrenSensitive(void* csModel, bool enable) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return; + } + { + try + { + model->SetChildrenSensitive(enable); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Model_GetChildrenSensitive(void* csModel) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + bool result; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return false; + } + { + try + { + result = model->GetChildrenSensitive(); + } + CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_SetImageBasedLightSource(void* csModel, char* csDiffuseUrl, char* csSpecularUrl, float scaleFactor) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return; + } + if(!csDiffuseUrl) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return; + } + std::string diffuseUrl(csDiffuseUrl); + if(!csSpecularUrl) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return; + } + std::string specularUrl(csSpecularUrl); + { + try + { + model->SetImageBasedLightSource(diffuseUrl, specularUrl, scaleFactor); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_SetImageBasedLightScaleFactor(void* csModel, float scaleFactor) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return; + } + { + try + { + model->SetImageBasedLightScaleFactor(scaleFactor); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Model_GetImageBasedLightScaleFactor(void* csModel) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + float scaleFactor = 1.0f; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return scaleFactor; + } + { + try + { + scaleFactor = model->GetImageBasedLightScaleFactor(); + } + CALL_CATCH_EXCEPTION(0.0f); + } + return scaleFactor; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Model_GetAnimationCount(void* csModel) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + unsigned int result; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return 0; + } + { + try + { + result = model->GetAnimationCount(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_GetAnimation_1(void* csModel, unsigned int index) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + Dali::Animation result; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return 0; + } + { + try + { + result = model->GetAnimation(index); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Animation((const Dali::Animation&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_GetAnimation_2(void* csModel, char* csName) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + Dali::Animation result; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return 0; + } + if(!csName) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string name(csName); + { + try + { + result = model->GetAnimation(name); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Animation((const Dali::Animation&)result); +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Model_GetCameraCount(void* csModel) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + unsigned int result; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return 0; + } + { + try + { + result = model->GetCameraCount(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_GenerateCamera(void* csModel, unsigned int index) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + Dali::CameraActor result; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return 0; + } + { + try + { + result = model->GenerateCamera(index); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::CameraActor((const Dali::CameraActor&)result); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Model_ApplyCamera(void* csModel, unsigned int index, void* csCameraActor) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + Dali::CameraActor* cameraActor = (Dali::CameraActor*)csCameraActor; + bool result; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return 0; + } + if(!cameraActor) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0); + return 0; + } + { + try + { + result = model->ApplyCamera(index, *cameraActor); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_FindChildModelNodeByName(void* csModel, char* nodeName) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + Dali::Scene3D::ModelNode result; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return nullptr; + } + + try + { + result = model->FindChildModelNodeByName(std::string_view(nodeName)); + } + CALL_CATCH_EXCEPTION(nullptr); + + return new Dali::Scene3D::ModelNode((const Dali::Scene3D::ModelNode&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_GenerateMotionDataAnimation(void* csModel, void* csMotionData) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; + Dali::Animation result; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return nullptr; + } + if(!motionData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); + return nullptr; + } + + try + { + result = model->GenerateMotionDataAnimation(*motionData); + } + CALL_CATCH_EXCEPTION(nullptr); + + return new Dali::Animation((const Dali::Animation&)result); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_SetMotionData(void* csModel, void* csMotionData) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return; + } + if(!motionData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); + return; + } + + try + { + model->SetMotionData(*motionData); + } + CALL_CATCH_EXCEPTION(); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_LoadBvhAnimation_1(void* csModel, char* csFileName, void* csScale, bool csUseRootNodeTranslate) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + Dali::Animation result; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return 0; + } + if(!csFileName) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for filename", 0); + return 0; + } + + Dali::Vector3 scale = Dali::Vector3::ONE; + // csScale is option. + if(csScale != nullptr) + { + scale = Dali::Vector3(*static_cast(csScale)); + } + + std::string filename(csFileName); + { + try + { + Dali::Scene3D::Loader::AnimationDefinition animationDefinition = Dali::Scene3D::Loader::LoadBvh(filename, "LoadedBvhAnimation", scale); + + if(csUseRootNodeTranslate && animationDefinition.GetPropertyCount() > 0u) + { + // We can assume that 0's property is for root translate + auto& property = animationDefinition.GetPropertyAt(0u); + auto& keyFrames = property.mKeyFrames; + + // Let we check that we can change animatable property + // TODO : If AnimateBetweenBy feature prepared, we can remove below logic. + if(keyFrames) + { + auto rootNode = model->FindChildByName(property.mNodeName); + if(rootNode) + { + // Get root node's current position and apply it into property animation. + auto rootNodePosition = rootNode.GetProperty(Dali::Actor::Property::POSITION); + + auto frameCount = Dali::DevelKeyFrames::GetKeyFrameCount(keyFrames); + for(auto i = 0u; i < frameCount; ++i) + { + float keyFrameProgress; + Dali::Property::Value keyFrameValue; + Dali::Vector3 valuePosition; + + Dali::DevelKeyFrames::GetKeyFrame(keyFrames, i, keyFrameProgress, keyFrameValue); + if(DALI_LIKELY(keyFrameValue.Get(valuePosition))) + { + Dali::DevelKeyFrames::SetKeyFrameValue(keyFrames, i, rootNodePosition + valuePosition); + } + } + } + } + } + + Dali::Scene3D::Loader::AnimatedProperty::GetActor getActor = [&model](const Dali::Scene3D::Loader::AnimatedProperty& property) -> Dali::Actor { + return model->FindChildByName(property.mNodeName); + }; + result = animationDefinition.ReAnimate(getActor); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Animation((const Dali::Animation&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_LoadBvhAnimation_2(void* csModel, char* csBuffer, int csBufferLength, void* csScale, bool csUseRootNodeTranslate) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + Dali::Animation result; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return 0; + } + if(!csBuffer) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for buffer", 0); + return 0; + } + + Dali::Vector3 scale = Dali::Vector3::ONE; + // csScale is option. + if(csScale != nullptr) + { + scale = Dali::Vector3(*static_cast(csScale)); + } + + const uint8_t* rawBuffer = reinterpret_cast(csBuffer); + { + try + { + Dali::Scene3D::Loader::AnimationDefinition animationDefinition = Dali::Scene3D::Loader::LoadBvhFromBuffer(rawBuffer, csBufferLength, "LoadedBvhAnimation", scale); + + if(csUseRootNodeTranslate && animationDefinition.GetPropertyCount() > 0u) + { + // We can assume that 0's property is for root translate + auto& property = animationDefinition.GetPropertyAt(0u); + auto& keyFrames = property.mKeyFrames; + + // Let we check that we can change animatable property + // TODO : If AnimateBetweenBy feature prepared, we can remove below logic. + if(keyFrames) + { + auto rootNode = model->FindChildByName(property.mNodeName); + if(rootNode) + { + // Get root node's current position and apply it into property animation. + auto rootNodePosition = rootNode.GetProperty(Dali::Actor::Property::POSITION); + + auto frameCount = Dali::DevelKeyFrames::GetKeyFrameCount(keyFrames); + for(auto i = 0u; i < frameCount; ++i) + { + float keyFrameProgress; + Dali::Property::Value keyFrameValue; + Dali::Vector3 valuePosition; + Dali::DevelKeyFrames::GetKeyFrame(keyFrames, i, keyFrameProgress, keyFrameValue); + if(DALI_LIKELY(keyFrameValue.Get(valuePosition))) + { + Dali::DevelKeyFrames::SetKeyFrameValue(keyFrames, i, rootNodePosition + valuePosition); + } + } + } + } + } + + Dali::Scene3D::Loader::AnimatedProperty::GetActor getActor = [&model](const Dali::Scene3D::Loader::AnimatedProperty& property) -> Dali::Actor { + return model->FindChildByName(property.mNodeName); + }; + result = animationDefinition.ReAnimate(getActor); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Animation((const Dali::Animation&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_LoadFacialAnimation_1(void* csModel, char* csFileName) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + Dali::Animation result; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return 0; + } + if(!csFileName) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for filename", 0); + return 0; + } + + std::string filename(csFileName); + { + try + { + Dali::Scene3D::Loader::AnimationDefinition animationDefinition = Dali::Scene3D::Loader::LoadFacialAnimation(filename); + Dali::Scene3D::Loader::AnimatedProperty::GetActor getActor = [&model](const Dali::Scene3D::Loader::AnimatedProperty& property) -> Dali::Actor { + return model->FindChildByName(property.mNodeName); + }; + result = animationDefinition.ReAnimate(getActor); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Animation((const Dali::Animation&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_LoadFacialAnimation_2(void* csModel, char* csBuffer, int csBufferLength) +{ + Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; + Dali::Animation result; + + if(!model) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return 0; + } + if(!csBuffer) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for buffer", 0); + return 0; + } + + const uint8_t* rawBuffer = reinterpret_cast(csBuffer); + { + try + { + Dali::Scene3D::Loader::AnimationDefinition animationDefinition = Dali::Scene3D::Loader::LoadFacialAnimationFromBuffer(rawBuffer, csBufferLength); + Dali::Scene3D::Loader::AnimatedProperty::GetActor getActor = [&model](const Dali::Scene3D::Loader::AnimatedProperty& property) -> Dali::Actor { + return model->FindChildByName(property.mNodeName); + }; + result = animationDefinition.ReAnimate(getActor); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Animation((const Dali::Animation&)result); +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-scene3d/motion-data-wrap.cpp b/dali-csharp-binder/dali-scene3d/motion-data-wrap.cpp new file mode 100644 index 00000000..708e03e5 --- /dev/null +++ b/dali-csharp-binder/dali-scene3d/motion-data-wrap.cpp @@ -0,0 +1,426 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionData_New_SWIG_0() +{ + Dali::Scene3D::MotionData result; + + { + try + { + result = Dali::Scene3D::MotionData::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::MotionData((const Dali::Scene3D::MotionData&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionData_New_SWIG_1(float durationSeconds) +{ + Dali::Scene3D::MotionData result; + + { + try + { + result = Dali::Scene3D::MotionData::New(durationSeconds); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::MotionData((const Dali::Scene3D::MotionData&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionData_SWIG_0() +{ + Dali::Scene3D::MotionData* result = 0; + + { + try + { + result = (Dali::Scene3D::MotionData*)new Dali::Scene3D::MotionData(); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionData_SWIG_1(void* csMotionData) +{ + Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; + Dali::Scene3D::MotionData* result = 0; + + if(!motionData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionData const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::MotionData*)new Dali::Scene3D::MotionData((Dali::Scene3D::MotionData const&)*motionData); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MotionData(void* csMotionData) +{ + Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; + { + try + { + delete motionData; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionData_Assign(void* csDestination, void* csSource) +{ + Dali::Scene3D::MotionData* destination = (Dali::Scene3D::MotionData*)csDestination; + Dali::Scene3D::MotionData* source = (Dali::Scene3D::MotionData*)csSource; + Dali::Scene3D::MotionData* result = 0; + + if(!source) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionData const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::MotionData*)&(destination)->operator=((Dali::Scene3D::MotionData const&)*source); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionData_DownCast(void* csHandle) +{ + Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; + Dali::Scene3D::MotionData result; + + if(!handle) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return 0; + } + { + try + { + result = Dali::Scene3D::MotionData::DownCast(*handle); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::MotionData((const Dali::Scene3D::MotionData&)result); +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_MotionData_GetMotionCount(void* csMotionData) +{ + Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; + unsigned int result; + + if(!motionData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); + return 0; + } + { + try + { + result = static_cast(motionData->GetMotionCount()); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionData_GetIndex(void* csMotionData, unsigned int index) +{ + Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; + Dali::Scene3D::MotionIndex result; + + if(!motionData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); + return 0; + } + { + try + { + result = motionData->GetIndex(static_cast(index)); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::MotionIndex((const Dali::Scene3D::MotionIndex&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionData_GetValue(void* csMotionData, unsigned int index) +{ + Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; + Dali::Scene3D::MotionValue result; + + if(!motionData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); + return 0; + } + { + try + { + result = motionData->GetValue(static_cast(index)); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::MotionValue((const Dali::Scene3D::MotionValue&)result); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_Add(void* csMotionData, void* csMotionIndex, void* csMotionValue) +{ + Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; + Dali::Scene3D::MotionIndex* motionIndex = (Dali::Scene3D::MotionIndex*)csMotionIndex; + Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue; + + if(!motionData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); + return; + } + if(!motionIndex) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionIndex", 0); + return; + } + if(!motionValue) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0); + return; + } + + { + try + { + motionData->Add(*motionIndex, *motionValue); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_Clear(void* csMotionData) +{ + Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; + + if(!motionData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); + return; + } + + { + try + { + motionData->Clear(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_SetDuration(void* csMotionData, float durationSeconds) +{ + Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; + + if(!motionData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); + return; + } + + { + try + { + motionData->SetDuration(durationSeconds); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MotionData_GetDuration(void* csMotionData) +{ + Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; + float result; + + if(!motionData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); + return 0.0f; + } + + { + try + { + result = motionData->GetDuration(); + } + CALL_CATCH_EXCEPTION(0.0f); + } + + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_LoadBvh(void* csMotionData, char* csFileName, void* csScale, bool csSynchronousLoad) +{ + Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; + + if(!motionData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); + return; + } + if(!csFileName) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for filename", 0); + return; + } + + Dali::Vector3 scale = Dali::Vector3::ONE; + // csScale is option. + if(csScale != nullptr) + { + scale = Dali::Vector3(*static_cast(csScale)); + } + + std::string filename(csFileName); + { + try + { + motionData->LoadBvh(filename, scale, csSynchronousLoad); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_LoadBvhFromBuffer(void* csMotionData, char* csBuffer, int csBufferLength, void* csScale, bool csSynchronousLoad) +{ + Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; + + if(!motionData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); + return; + } + if(!csBuffer) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for buffer", 0); + return; + } + + Dali::Vector3 scale = Dali::Vector3::ONE; + // csScale is option. + if(csScale != nullptr) + { + scale = Dali::Vector3(*static_cast(csScale)); + } + + const uint8_t* rawBuffer = reinterpret_cast(csBuffer); + { + try + { + motionData->LoadBvhFromBuffer(rawBuffer, csBufferLength, scale, csSynchronousLoad); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_LoadFacialAnimation(void* csMotionData, char* csFileName, bool csSynchronousLoad) +{ + Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; + + if(!motionData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); + return; + } + if(!csFileName) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for filename", 0); + return; + } + + std::string filename(csFileName); + { + try + { + motionData->LoadFacialAnimation(filename, csSynchronousLoad); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_LoadFacialAnimationFromBuffer(void* csMotionData, char* csBuffer, int csBufferLength, bool csSynchronousLoad) +{ + Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; + + if(!motionData) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); + return; + } + if(!csBuffer) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for buffer", 0); + return; + } + + const uint8_t* rawBuffer = reinterpret_cast(csBuffer); + { + try + { + motionData->LoadFacialAnimationFromBuffer(rawBuffer, csBufferLength, csSynchronousLoad); + } + CALL_CATCH_EXCEPTION(); + } +} + +// Signals +GENERATE_SIGNAL(Dali::Scene3D::MotionData*, void(*)(Dali::Scene3D::MotionData), Dali_MotionData, LoadCompletedSignal); +// CSharp_Dali_MotionData_LoadCompletedSignal_Connect +// CSharp_Dali_MotionData_LoadCompletedSignal_Disconnect + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-scene3d/motion-index-wrap.cpp b/dali-csharp-binder/dali-scene3d/motion-index-wrap.cpp new file mode 100644 index 00000000..b52dd8a2 --- /dev/null +++ b/dali-csharp-binder/dali-scene3d/motion-index-wrap.cpp @@ -0,0 +1,720 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// MotionIndex + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionIndex_SWIG_0() +{ + Dali::Scene3D::MotionIndex* result = 0; + + { + try + { + result = (Dali::Scene3D::MotionIndex*)new Dali::Scene3D::MotionIndex(); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionIndex_SWIG_1(void* csMotionIndex) +{ + Dali::Scene3D::MotionIndex* motionIndex = (Dali::Scene3D::MotionIndex*)csMotionIndex; + Dali::Scene3D::MotionIndex* result = 0; + + if(!motionIndex) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionIndex const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::MotionIndex*)new Dali::Scene3D::MotionIndex((Dali::Scene3D::MotionIndex const&)*motionIndex); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MotionIndex(void* csMotionIndex) +{ + Dali::Scene3D::MotionIndex* motionIndex = (Dali::Scene3D::MotionIndex*)csMotionIndex; + { + try + { + delete motionIndex; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionIndex_Assign(void* csDestination, void* csSource) +{ + Dali::Scene3D::MotionIndex* destination = (Dali::Scene3D::MotionIndex*)csDestination; + Dali::Scene3D::MotionIndex* source = (Dali::Scene3D::MotionIndex*)csSource; + Dali::Scene3D::MotionIndex* result = 0; + + if(!source) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionIndex const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::MotionIndex*)&(destination)->operator=((Dali::Scene3D::MotionIndex const&)*source); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionIndex_DownCast(void* csHandle) +{ + Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; + Dali::Scene3D::MotionIndex result; + + if(!handle) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return 0; + } + { + try + { + result = Dali::Scene3D::MotionIndex::DownCast(*handle); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::MotionIndex((const Dali::Scene3D::MotionIndex&)result); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionIndex_SetModelNodeId(void* csMotionIndex, void* csPropertyKey) +{ + Dali::Scene3D::MotionIndex* motionIndex = (Dali::Scene3D::MotionIndex*)csMotionIndex; + Dali::Property::Key* propertyKey = (Dali::Property::Key*)csPropertyKey; + + if(!motionIndex) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionIndex", 0); + return; + } + if(!propertyKey) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0); + return; + } + { + try + { + motionIndex->SetModelNodeId(*propertyKey); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionIndex_GetModelNodeId(void* csMotionIndex) +{ + Dali::Scene3D::MotionIndex* motionIndex = (Dali::Scene3D::MotionIndex*)csMotionIndex; + Dali::Property::Key result = Dali::Property::INVALID_KEY; + + if(!motionIndex) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionIndex", 0); + return 0; + } + { + try + { + result = motionIndex->GetModelNodeId(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Property::Key((Dali::Property::Key const &)result); +} + +// BlendShapeIndex + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_BlendShapeIndex_New_SWIG_0() +{ + Dali::Scene3D::BlendShapeIndex result; + + { + try + { + result = Dali::Scene3D::BlendShapeIndex::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::BlendShapeIndex((const Dali::Scene3D::BlendShapeIndex&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_BlendShapeIndex_New_SWIG_1(void* csBlendShapePropertyKey) +{ + Dali::Property::Key* blendShapePropertyKey = (Dali::Property::Key*)csBlendShapePropertyKey; + Dali::Scene3D::BlendShapeIndex result; + + if(!blendShapePropertyKey) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0); + return 0; + } + { + try + { + result = Dali::Scene3D::BlendShapeIndex::New(*blendShapePropertyKey); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::BlendShapeIndex((const Dali::Scene3D::BlendShapeIndex&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_BlendShapeIndex_New_SWIG_2(void* csModelNodePropertKey, void* csBlendShapePropertyKey) +{ + Dali::Property::Key* modelNodePropertyKey = (Dali::Property::Key*)csModelNodePropertKey; + Dali::Property::Key* blendShapePropertyKey = (Dali::Property::Key*)csBlendShapePropertyKey; + Dali::Scene3D::BlendShapeIndex result; + + if(!modelNodePropertyKey) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "modelNodePropertyKey Dali::Property::Key const & type is null", 0); + return 0; + } + if(!blendShapePropertyKey) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "blendShapePropertyKey Dali::Property::Key const & type is null", 0); + return 0; + } + { + try + { + result = Dali::Scene3D::BlendShapeIndex::New(*modelNodePropertyKey, *blendShapePropertyKey); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::BlendShapeIndex((const Dali::Scene3D::BlendShapeIndex&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_BlendShapeIndex_SWIG_0() +{ + Dali::Scene3D::BlendShapeIndex* result = 0; + + { + try + { + result = (Dali::Scene3D::BlendShapeIndex*)new Dali::Scene3D::BlendShapeIndex(); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_BlendShapeIndex_SWIG_1(void* csBlendShapeIndex) +{ + Dali::Scene3D::BlendShapeIndex* blendShapeIndex = (Dali::Scene3D::BlendShapeIndex*)csBlendShapeIndex; + Dali::Scene3D::BlendShapeIndex* result = 0; + + if(!blendShapeIndex) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::BlendShapeIndex const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::BlendShapeIndex*)new Dali::Scene3D::BlendShapeIndex((Dali::Scene3D::BlendShapeIndex const&)*blendShapeIndex); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BlendShapeIndex(void* csBlendShapeIndex) +{ + Dali::Scene3D::BlendShapeIndex* blendShapeIndex = (Dali::Scene3D::BlendShapeIndex*)csBlendShapeIndex; + { + try + { + delete blendShapeIndex; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_BlendShapeIndex_Assign(void* csDestination, void* csSource) +{ + Dali::Scene3D::BlendShapeIndex* destination = (Dali::Scene3D::BlendShapeIndex*)csDestination; + Dali::Scene3D::BlendShapeIndex* source = (Dali::Scene3D::BlendShapeIndex*)csSource; + Dali::Scene3D::BlendShapeIndex* result = 0; + + if(!source) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::BlendShapeIndex const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::BlendShapeIndex*)&(destination)->operator=((Dali::Scene3D::BlendShapeIndex const&)*source); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_BlendShapeIndex_DownCast(void* csHandle) +{ + Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; + Dali::Scene3D::BlendShapeIndex result; + + if(!handle) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return 0; + } + { + try + { + result = Dali::Scene3D::BlendShapeIndex::DownCast(*handle); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::BlendShapeIndex((const Dali::Scene3D::BlendShapeIndex&)result); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BlendShapeIndex_SetBlendShapeId(void* csBlendShapeIndex, void* csBlendShapePropertyKey) +{ + Dali::Scene3D::BlendShapeIndex* blendShapeIndex = (Dali::Scene3D::BlendShapeIndex*)csBlendShapeIndex; + Dali::Property::Key* blendShapePropertyKey = (Dali::Property::Key*)csBlendShapePropertyKey; + + if(!blendShapeIndex) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::BlendShapeIndex const & type is null", 0); + return; + } + if(!blendShapePropertyKey) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0); + return; + } + { + try + { + blendShapeIndex->SetBlendShapeId(*blendShapePropertyKey); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_BlendShapeIndex_GetBlendShapeId(void* csBlendShapeIndex) +{ + Dali::Scene3D::BlendShapeIndex* blendShapeIndex = (Dali::Scene3D::BlendShapeIndex*)csBlendShapeIndex; + Dali::Property::Key result = Dali::Property::INVALID_KEY; + + if(!blendShapeIndex) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::BlendShapeIndex const & type is null", 0); + return 0; + } + { + try + { + result = blendShapeIndex->GetBlendShapeId(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Property::Key((Dali::Property::Key const &)result); +} + +// MotionPropertyIndex + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionPropertyIndex_New_SWIG_0() +{ + Dali::Scene3D::MotionPropertyIndex result; + + { + try + { + result = Dali::Scene3D::MotionPropertyIndex::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::MotionPropertyIndex((const Dali::Scene3D::MotionPropertyIndex&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionPropertyIndex_New_SWIG_1(void* csModelNodePropertKey, void* csPropertyKey) +{ + Dali::Property::Key* modelNodePropertyKey = (Dali::Property::Key*)csModelNodePropertKey; + Dali::Property::Key* propertyKey = (Dali::Property::Key*)csPropertyKey; + Dali::Scene3D::MotionPropertyIndex result; + + if(!modelNodePropertyKey) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "modelNodePropertyKey Dali::Property::Key const & type is null", 0); + return 0; + } + if(!propertyKey) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "propertyKey Dali::Property::Key const & type is null", 0); + return 0; + } + { + try + { + result = Dali::Scene3D::MotionPropertyIndex::New(*modelNodePropertyKey, *propertyKey); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::MotionPropertyIndex((const Dali::Scene3D::MotionPropertyIndex&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionPropertyIndex_SWIG_0() +{ + Dali::Scene3D::MotionPropertyIndex* result = 0; + + { + try + { + result = (Dali::Scene3D::MotionPropertyIndex*)new Dali::Scene3D::MotionPropertyIndex(); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionPropertyIndex_SWIG_1(void* csMotionPropertyIndex) +{ + Dali::Scene3D::MotionPropertyIndex* motionPropertyIndex = (Dali::Scene3D::MotionPropertyIndex*)csMotionPropertyIndex; + Dali::Scene3D::MotionPropertyIndex* result = 0; + + if(!motionPropertyIndex) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionPropertyIndex const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::MotionPropertyIndex*)new Dali::Scene3D::MotionPropertyIndex((Dali::Scene3D::MotionPropertyIndex const&)*motionPropertyIndex); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MotionPropertyIndex(void* csMotionPropertyIndex) +{ + Dali::Scene3D::MotionPropertyIndex* motionPropertyIndex = (Dali::Scene3D::MotionPropertyIndex*)csMotionPropertyIndex; + { + try + { + delete motionPropertyIndex; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionPropertyIndex_Assign(void* csDestination, void* csSource) +{ + Dali::Scene3D::MotionPropertyIndex* destination = (Dali::Scene3D::MotionPropertyIndex*)csDestination; + Dali::Scene3D::MotionPropertyIndex* source = (Dali::Scene3D::MotionPropertyIndex*)csSource; + Dali::Scene3D::MotionPropertyIndex* result = 0; + + if(!source) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionPropertyIndex const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::MotionPropertyIndex*)&(destination)->operator=((Dali::Scene3D::MotionPropertyIndex const&)*source); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionPropertyIndex_DownCast(void* csHandle) +{ + Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; + Dali::Scene3D::MotionPropertyIndex result; + + if(!handle) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return 0; + } + { + try + { + result = Dali::Scene3D::MotionPropertyIndex::DownCast(*handle); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::MotionPropertyIndex((const Dali::Scene3D::MotionPropertyIndex&)result); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionPropertyIndex_SetPropertyId(void* csMotionPropertyIndex, void* csPropertyKey) +{ + Dali::Scene3D::MotionPropertyIndex* motionPropertyIndex = (Dali::Scene3D::MotionPropertyIndex*)csMotionPropertyIndex; + Dali::Property::Key* propertyKey = (Dali::Property::Key*)csPropertyKey; + + if(!motionPropertyIndex) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionPropertyIndex const & type is null", 0); + return; + } + if(!propertyKey) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0); + return; + } + { + try + { + motionPropertyIndex->SetPropertyId(*propertyKey); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionPropertyIndex_GetPropertyId(void* csMotionPropertyIndex) +{ + Dali::Scene3D::MotionPropertyIndex* motionPropertyIndex = (Dali::Scene3D::MotionPropertyIndex*)csMotionPropertyIndex; + Dali::Property::Key result = Dali::Property::INVALID_KEY; + + if(!motionPropertyIndex) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionPropertyIndex const & type is null", 0); + return 0; + } + { + try + { + result = motionPropertyIndex->GetPropertyId(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Property::Key((Dali::Property::Key const &)result); +} + +// MotionTransformIndex + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionTransformIndex_New_SWIG_0() +{ + Dali::Scene3D::MotionTransformIndex result; + + { + try + { + result = Dali::Scene3D::MotionTransformIndex::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::MotionTransformIndex((const Dali::Scene3D::MotionTransformIndex&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionTransformIndex_New_SWIG_1(void* csModelNodePropertKey, int csTransformType) +{ + Dali::Property::Key* modelNodePropertyKey = (Dali::Property::Key*)csModelNodePropertKey; + Dali::Scene3D::MotionTransformIndex result; + + if(!modelNodePropertyKey) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "modelNodePropertyKey Dali::Property::Key const & type is null", 0); + return 0; + } + { + try + { + result = Dali::Scene3D::MotionTransformIndex::New(*modelNodePropertyKey, static_cast(csTransformType)); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::MotionTransformIndex((const Dali::Scene3D::MotionTransformIndex&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionTransformIndex_SWIG_0() +{ + Dali::Scene3D::MotionTransformIndex* result = 0; + + { + try + { + result = (Dali::Scene3D::MotionTransformIndex*)new Dali::Scene3D::MotionTransformIndex(); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionTransformIndex_SWIG_1(void* csMotionTransformIndex) +{ + Dali::Scene3D::MotionTransformIndex* motionTransformIndex = (Dali::Scene3D::MotionTransformIndex*)csMotionTransformIndex; + Dali::Scene3D::MotionTransformIndex* result = 0; + + if(!motionTransformIndex) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionTransformIndex const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::MotionTransformIndex*)new Dali::Scene3D::MotionTransformIndex((Dali::Scene3D::MotionTransformIndex const&)*motionTransformIndex); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MotionTransformIndex(void* csMotionTransformIndex) +{ + Dali::Scene3D::MotionTransformIndex* motionTransformIndex = (Dali::Scene3D::MotionTransformIndex*)csMotionTransformIndex; + { + try + { + delete motionTransformIndex; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionTransformIndex_Assign(void* csDestination, void* csSource) +{ + Dali::Scene3D::MotionTransformIndex* destination = (Dali::Scene3D::MotionTransformIndex*)csDestination; + Dali::Scene3D::MotionTransformIndex* source = (Dali::Scene3D::MotionTransformIndex*)csSource; + Dali::Scene3D::MotionTransformIndex* result = 0; + + if(!source) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionTransformIndex const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::MotionTransformIndex*)&(destination)->operator=((Dali::Scene3D::MotionTransformIndex const&)*source); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionTransformIndex_DownCast(void* csHandle) +{ + Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; + Dali::Scene3D::MotionTransformIndex result; + + if(!handle) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return 0; + } + { + try + { + result = Dali::Scene3D::MotionTransformIndex::DownCast(*handle); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::MotionTransformIndex((const Dali::Scene3D::MotionTransformIndex&)result); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionTransformIndex_SetTransformType(void* csMotionTransformIndex, int csTransformType) +{ + Dali::Scene3D::MotionTransformIndex* motionTransformIndex = (Dali::Scene3D::MotionTransformIndex*)csMotionTransformIndex; + + if(!motionTransformIndex) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionTransformIndex const & type is null", 0); + return; + } + { + try + { + motionTransformIndex->SetTransformType(static_cast(csTransformType)); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MotionTransformIndex_GetTransformType(void* csMotionTransformIndex) +{ + Dali::Scene3D::MotionTransformIndex* motionTransformIndex = (Dali::Scene3D::MotionTransformIndex*)csMotionTransformIndex; + int result; + + if(!motionTransformIndex) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionTransformIndex const & type is null", 0); + return 0; + } + { + try + { + result = static_cast(motionTransformIndex->GetTransformType()); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-scene3d/motion-value-wrap.cpp b/dali-csharp-binder/dali-scene3d/motion-value-wrap.cpp new file mode 100644 index 00000000..160a6a70 --- /dev/null +++ b/dali-csharp-binder/dali-scene3d/motion-value-wrap.cpp @@ -0,0 +1,309 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_New_SWIG_0() +{ + Dali::Scene3D::MotionValue result; + + { + try + { + result = Dali::Scene3D::MotionValue::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::MotionValue((const Dali::Scene3D::MotionValue&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_New_SWIG_1(void* csPropertyValue) +{ + Dali::Property::Value* propertyValue = (Dali::Property::Value*)csPropertyValue; + Dali::Scene3D::MotionValue result; + + if(!propertyValue) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); + return 0; + } + { + try + { + result = Dali::Scene3D::MotionValue::New(*propertyValue); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::MotionValue((const Dali::Scene3D::MotionValue&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_New_SWIG_2(void* csKeyFrames) +{ + Dali::KeyFrames* keyFrames = (Dali::KeyFrames*)csKeyFrames; + Dali::Scene3D::MotionValue result; + + if(!keyFrames) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0); + return 0; + } + { + try + { + result = Dali::Scene3D::MotionValue::New(*keyFrames); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::MotionValue((const Dali::Scene3D::MotionValue&)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionValue_SWIG_0() +{ + Dali::Scene3D::MotionValue* result = 0; + + { + try + { + result = (Dali::Scene3D::MotionValue*)new Dali::Scene3D::MotionValue(); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionValue_SWIG_1(void* csMotionValue) +{ + Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue; + Dali::Scene3D::MotionValue* result = 0; + + if(!motionValue) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionValue const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::MotionValue*)new Dali::Scene3D::MotionValue((Dali::Scene3D::MotionValue const&)*motionValue); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MotionValue(void* csMotionValue) +{ + Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue; + { + try + { + delete motionValue; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_Assign(void* csDestination, void* csSource) +{ + Dali::Scene3D::MotionValue* destination = (Dali::Scene3D::MotionValue*)csDestination; + Dali::Scene3D::MotionValue* source = (Dali::Scene3D::MotionValue*)csSource; + Dali::Scene3D::MotionValue* result = 0; + + if(!source) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionValue const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::MotionValue*)&(destination)->operator=((Dali::Scene3D::MotionValue const&)*source); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_DownCast(void* csHandle) +{ + Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; + Dali::Scene3D::MotionValue result; + + if(!handle) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); + return 0; + } + { + try + { + result = Dali::Scene3D::MotionValue::DownCast(*handle); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::MotionValue((const Dali::Scene3D::MotionValue&)result); +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MotionValue_GetValueType(void* csMotionValue) +{ + Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue; + int result; + + if(!motionValue) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0); + return 0; + } + { + try + { + result = static_cast(motionValue->GetValueType()); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionValue_SetValue_PropertyValue(void* csMotionValue, void* csPropertyValue) +{ + Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue; + Dali::Property::Value* propertyValue = (Dali::Property::Value*)csPropertyValue; + + if(!motionValue) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0); + return; + } + if(!propertyValue) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); + return; + } + { + try + { + motionValue->SetValue(*propertyValue); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionValue_SetValue_KeyFrames(void* csMotionValue, void* csKeyFrames) +{ + Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue; + Dali::KeyFrames* keyFrames = (Dali::KeyFrames*)csKeyFrames; + + if(!motionValue) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0); + return; + } + if(!keyFrames) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0); + return; + } + { + try + { + motionValue->SetValue(*keyFrames); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionValue_Clear(void* csMotionValue) +{ + Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue; + + if(!motionValue) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0); + return; + } + { + try + { + motionValue->Clear(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_GetPropertyValue(void* csMotionValue) +{ + Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue; + Dali::Property::Value result; + + if(!motionValue) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0); + return 0; + } + { + try + { + result = motionValue->GetPropertyValue(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Property::Value((Dali::Property::Value const &)result); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_GetKeyFrames(void* csMotionValue) +{ + Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue; + Dali::KeyFrames result; + + if(!motionValue) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0); + return 0; + } + { + try + { + result = motionValue->GetKeyFrames(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::KeyFrames((Dali::KeyFrames const &)result); +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-scene3d/scene-view-wrap.cpp b/dali-csharp-binder/dali-scene3d/scene-view-wrap.cpp new file mode 100755 index 00000000..fd01ed84 --- /dev/null +++ b/dali-csharp-binder/dali-scene3d/scene-view-wrap.cpp @@ -0,0 +1,562 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SceneView_New_SWIG_0() + { + Dali::Scene3D::SceneView result; + { + try + { + result = Dali::Scene3D::SceneView::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::SceneView((const Dali::Scene3D::SceneView &)result); + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_SceneView_SWIG_0() + { + Dali::Scene3D::SceneView *result = 0; + + { + try + { + result = (Dali::Scene3D::SceneView *)new Dali::Scene3D::SceneView(); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void *)result; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_SceneView_SWIG_1(void *csSceneView) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + Dali::Scene3D::SceneView *result = 0; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::SceneView const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::SceneView *)new Dali::Scene3D::SceneView((Dali::Scene3D::SceneView const &)*sceneView); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void *)result; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SceneView(void *csSceneView) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + { + try + { + delete sceneView; + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SceneView_Assign(void *csDestination, void *csSource) + { + Dali::Scene3D::SceneView *destination = (Dali::Scene3D::SceneView *)csDestination; + Dali::Scene3D::SceneView *source = (Dali::Scene3D::SceneView *)csSource; + Dali::Scene3D::SceneView *result = 0; + + if (!source) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::SceneView const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Scene3D::SceneView *)&(destination)->operator=((Dali::Scene3D::SceneView const &)*source); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void *)result; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SceneView_DownCast(void *csHandle) + { + Dali::BaseHandle *handle = (Dali::BaseHandle *)csHandle; + Dali::Scene3D::SceneView result; + + if (!handle) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return 0; + } + { + try + { + result = Dali::Scene3D::SceneView::DownCast(*handle); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Scene3D::SceneView((const Dali::Scene3D::SceneView &)result); + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_AddCamera(void *csSceneView, void *csCamera) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + Dali::CameraActor *cameraActor = (Dali::CameraActor *)csCamera; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return; + } + if (!cameraActor) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0); + return; + } + { + try + { + sceneView->AddCamera(*cameraActor); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_RemoveCamera(void *csSceneView, void *csCamera) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + Dali::CameraActor *cameraActor = (Dali::CameraActor *)csCamera; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return; + } + if (!cameraActor) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0); + return; + } + { + try + { + sceneView->RemoveCamera(*cameraActor); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_SceneView_GetCameraCount(void *csSceneView) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + uint32_t result = 0; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return 0; + } + { + try + { + result = sceneView->GetCameraCount(); + } + CALL_CATCH_EXCEPTION(0); + } + return result; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SceneView_GetSelectedCamera(void *csSceneView) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + Dali::CameraActor cameraActor; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return 0; + } + { + try + { + cameraActor = sceneView->GetSelectedCamera(); + } + CALL_CATCH_EXCEPTION(0); + } + Dali::CameraActor *result = new Dali::CameraActor((const Dali::CameraActor &)cameraActor); + return result; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SceneView_GetCamera_0(void *csSceneView, uint32_t index) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + Dali::CameraActor cameraActor; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return 0; + } + { + try + { + cameraActor = sceneView->GetCamera(index); + } + CALL_CATCH_EXCEPTION(0); + } + Dali::CameraActor *result = new Dali::CameraActor((const Dali::CameraActor &)cameraActor); + return result; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SceneView_GetCamera_1(void *csSceneView, char *name) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + Dali::CameraActor cameraActor; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return 0; + } + { + try + { + cameraActor = sceneView->GetCamera(std::string(name)); + } + CALL_CATCH_EXCEPTION(0); + } + Dali::CameraActor *result = new Dali::CameraActor((const Dali::CameraActor &)cameraActor); + return result; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_SelectCamera_0(void *csSceneView, uint32_t index) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return; + } + { + try + { + sceneView->SelectCamera(index); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_SelectCamera_1(void *csSceneView, char *name) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return; + } + { + try + { + sceneView->SelectCamera(std::string(name)); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_SetImageBasedLightSource(void *csSceneView, char *diffuseUrl, char *specularUrl, float scaleFactor) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return; + } + { + try + { + sceneView->SetImageBasedLightSource(std::string(diffuseUrl), std::string(specularUrl), scaleFactor); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_SetImageBasedLightScaleFactor(void *csSceneView, float scaleFactor) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return; + } + { + try + { + sceneView->SetImageBasedLightScaleFactor(scaleFactor); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT float SWIGSTDCALL CSharp_Dali_SceneView_GetImageBasedLightScaleFactor(void *csSceneView) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + float scaleFactor = 1.0f; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelView", 0); + return scaleFactor; + } + { + try + { + scaleFactor = sceneView->GetImageBasedLightScaleFactor(); + } + CALL_CATCH_EXCEPTION(0.0f); + } + return scaleFactor; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_UseFramebuffer(void *csSceneView, bool useFramebuffer) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return; + } + { + try + { + sceneView->UseFramebuffer(useFramebuffer); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SceneView_IsUsingFramebuffer(void *csSceneView) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + bool result = false; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return false; + } + { + try + { + result = sceneView->IsUsingFramebuffer(); + } + CALL_CATCH_EXCEPTION(0); + } + return result; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_SetFramebufferMultiSamplingLevel(void *csSceneView, uint32_t multiSamplingLevel) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return; + } + { + try + { + sceneView->SetFramebufferMultiSamplingLevel(static_cast(multiSamplingLevel)); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_SceneView_GetFramebufferMultiSamplingLevel(void *csSceneView) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + uint32_t result = 0u; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return 0; + } + { + try + { + result = static_cast(sceneView->GetFramebufferMultiSamplingLevel()); + } + CALL_CATCH_EXCEPTION(0); + } + return result; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_SetSkybox(void *csSceneView, char *skyboxUrl) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return; + } + if (!skyboxUrl) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null string", 0); + return; + } + { + try + { + sceneView->SetSkybox(std::string(skyboxUrl)); + } + CALL_CATCH_EXCEPTION(); + } + return; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_SetSkyboxEnvironmentMapType(void *csSceneView, int skyboxEnvironmentMapType) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return; + } + { + try + { + sceneView->SetSkyboxEnvironmentMapType((Dali::Scene3D::EnvironmentMapType)skyboxEnvironmentMapType); + } + CALL_CATCH_EXCEPTION(); + } + return; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_SetSkyboxIntensity(void *csSceneView, float intensity) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return; + } + { + try + { + sceneView->SetSkyboxIntensity(intensity); + } + CALL_CATCH_EXCEPTION(); + } + return; + } + + SWIGEXPORT float SWIGSTDCALL CSharp_Dali_SceneView_GetSkyboxIntensity(void *csSceneView) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + float intensity = 1.0f; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return intensity; + } + { + try + { + intensity = sceneView->GetSkyboxIntensity(); + } + CALL_CATCH_EXCEPTION(0.0f); + } + return intensity; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_SetSkyboxOrientation(void *csSceneView, void *csOrientation) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + Dali::Quaternion *orientation = (Dali::Quaternion *)csOrientation; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return; + } + if (!orientation) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Quaternion", 0); + return; + } + { + try + { + sceneView->SetSkyboxOrientation(*orientation); + } + CALL_CATCH_EXCEPTION(); + } + return; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SceneView_GetSkyboxOrientation(void *csSceneView) + { + Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; + Dali::Quaternion orientation; + + if (!sceneView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); + return 0; + } + { + try + { + orientation = sceneView->GetSkyboxOrientation(); + } + CALL_CATCH_EXCEPTION(0); + } + Dali::Quaternion *result = new Dali::Quaternion((const Dali::Quaternion &)orientation); + return result; + } + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/canvas-view-wrap.cpp b/dali-csharp-binder/dali-toolkit/canvas-view-wrap.cpp new file mode 100644 index 00000000..34112d24 --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/canvas-view-wrap.cpp @@ -0,0 +1,1654 @@ +/* + * Copyright (c) 2022 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include +#include +#include +#include +#include + +// INTERNAL INCLUDES +#include + +using namespace Dali; +using namespace Dali::Toolkit; + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void *SWIGSTDCALL +CSharp_Dali_CanvasView_New__SWIG_0(char *pViewBox) { + Dali::ImageDimensions viewBox; + Dali::Toolkit::CanvasView result; + + if (!pViewBox) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + viewBox = *(Dali::ImageDimensions *)pViewBox; + { + try { + result = Dali::Toolkit::CanvasView::New( + Vector2(viewBox.GetWidth(), viewBox.GetHeight())); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Toolkit::CanvasView( + (const Dali::Toolkit::CanvasView &)result); +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_CanvasView_New__SWIG_1() { + Dali::Toolkit::CanvasView result; + + { + try { + result = Dali::Toolkit::CanvasView::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Toolkit::CanvasView( + (const Dali::Toolkit::CanvasView &)result); +} + +SWIGEXPORT bool SWIGSTDCALL +CSharp_Dali_CanvasView_AddDrawable(char *pCanvasView, char *pDrawable) { + Dali::Toolkit::CanvasView canvasView; + Dali::CanvasRenderer::Drawable drawable; + bool result = true; + + if (!pCanvasView) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::Toolkit::CanvasView", 0); + return false; + } + canvasView = *(Dali::Toolkit::CanvasView *)pCanvasView; + + if (!pDrawable) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); + return false; + } + drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; + { + try { + canvasView.AddDrawable(drawable); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL +CSharp_Dali_CanvasView_RemoveDrawable(char *pCanvasView, char *pDrawable) { + Dali::Toolkit::CanvasView canvasView; + Dali::CanvasRenderer::Drawable drawable; + bool result = true; + + if (!pCanvasView) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::Toolkit::CanvasView", 0); + return false; + } + canvasView = *(Dali::Toolkit::CanvasView *)pCanvasView; + + if (!pDrawable) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); + return false; + } + drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; + { + try { + canvasView.RemoveDrawable(drawable); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_CanvasView_RemoveAllDrawables(char *pCanvasView) { + Dali::Toolkit::CanvasView canvasView; + Dali::CanvasRenderer::Drawable drawable; + + if (!pCanvasView) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::Toolkit::CanvasView", 0); + return; + } + canvasView = *(Dali::Toolkit::CanvasView *)pCanvasView; + + { + try { + canvasView.RemoveAllDrawables(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CanvasView(void *pCanvasView) { + Dali::Toolkit::CanvasView *pTargetCanvasView = nullptr; + + if (!pCanvasView) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::Toolkit::CanvasView", 0); + } + + pTargetCanvasView = (Dali::Toolkit::CanvasView *)pCanvasView; + { + try { + if (pTargetCanvasView) { + delete pTargetCanvasView; + } + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CanvasView_Property_VIEWBOX_get() { + return (int)Toolkit::CanvasView::Property::VIEW_BOX; +} + +// Dali::CanvasRenderer::Drawable Wrapper + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Drawable_SetOpacity(char *pDrawable, + float opacity) { + Dali::CanvasRenderer::Drawable drawable; + + if (!pDrawable) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); + return; + } + drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; + + { + try { + drawable.SetOpacity(opacity); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Drawable_GetOpacity(char *pDrawable) { + Dali::CanvasRenderer::Drawable drawable; + float opacity = 0.0f; + + if (!pDrawable) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); + return 0.0; + } + drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; + { + try { + opacity = drawable.GetOpacity(); + } + CALL_CATCH_EXCEPTION(0); + } + + return opacity; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_Translate(char *pDrawable, + float x, float y) { + Dali::CanvasRenderer::Drawable drawable; + bool result = false; + + if (!pDrawable) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); + return false; + } + drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; + { + try { + result = drawable.Translate(Vector2(x, y)); + } + CALL_CATCH_EXCEPTION(false); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_Scale(char *pDrawable, + float scale) { + Dali::CanvasRenderer::Drawable drawable; + bool result = false; + + if (!pDrawable) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); + return false; + } + drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; + + { + try { + result = drawable.Scale(scale); + } + CALL_CATCH_EXCEPTION(false); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_Rotate(char *pDrawable, + float degree) { + Dali::CanvasRenderer::Drawable drawable; + bool result = false; + + if (!pDrawable) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); + return false; + } + drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; + { + try { + result = drawable.Rotate(Dali::Degree(degree)); + } + CALL_CATCH_EXCEPTION(false); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_Transform(char *pDrawable, + float *pTransform) { + Dali::CanvasRenderer::Drawable drawable; + bool result = false; + + if (!pDrawable) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); + return false; + } + drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; + + if (!pTransform) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, + "Dali::Matrix3 const & type is null", + 0); + return false; + } + + { + try { + result = drawable.Transform( + Dali::Matrix3(pTransform[0], pTransform[1], pTransform[2], + pTransform[3], pTransform[4], pTransform[5], + pTransform[6], pTransform[7], pTransform[8])); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void *SWIGSTDCALL +CSharp_Dali_Drawable_GetBoundingBox(char *pDrawable) { + Dali::CanvasRenderer::Drawable drawable; + Dali::Rect result; + + if (!pDrawable) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return 0; + } + drawable = *(Dali::CanvasRenderer::Shape *)pDrawable; + { + try { + result = drawable.GetBoundingBox(); + } + CALL_CATCH_EXCEPTION(0); + } + + // Note: The float type Rectangle class is not ready yet. + // Therefore, it transmits data in Vector4 class. + // This type should later be changed to the appropriate data type. + return new Dali::Vector4(result.x, result.y, result.width, result.height); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_SetClipPath(char *pDrawable, + char *pClip) { + Dali::CanvasRenderer::Drawable drawable; + Dali::CanvasRenderer::Drawable clip; + bool result = false; + + if (!pDrawable) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); + return false; + } + drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; + + if (!pClip) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); + return false; + } + clip = *(Dali::CanvasRenderer::Drawable *)pClip; + + { + try { + result = drawable.SetClipPath(clip); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_SetMask(char *pDrawable, + char *pMask, + int maskType) { + Dali::CanvasRenderer::Drawable drawable; + Dali::CanvasRenderer::Drawable mask; + bool result = false; + + if (!pDrawable) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); + return false; + } + drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; + + if (!pMask) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); + return false; + } + mask = *(Dali::CanvasRenderer::Drawable *)pMask; + + { + try { + result = drawable.SetMask( + mask, + static_cast(maskType)); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +// Dali::CanvasRenderer::Picture Wrapper + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Picture_New() { + Dali::CanvasRenderer::Picture picture; + + { + try { + picture = Dali::CanvasRenderer::Picture::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::CanvasRenderer::Picture( + (const Dali::CanvasRenderer::Picture &)picture); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Picture_Load(char *pPicture, + char *pUrl) { + Dali::CanvasRenderer::Picture picture; + bool result = false; + + if (!pPicture) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Picture", 0); + return false; + } + picture = *(Dali::CanvasRenderer::Picture *)pPicture; + + if (!pUrl) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, + "Attempt to dereference null string", + 0); + return false; + } + std::string url(pUrl); + + { + try { + result = picture.Load(url); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Picture_SetSize(char *pPicture, + void *pSize) { + Dali::CanvasRenderer::Picture picture; + bool result = false; + + if (!pPicture) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Picture", 0); + return false; + } + picture = *(Dali::CanvasRenderer::Picture *)pPicture; + + if (!pSize) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::Vector2", 0); + return false; + } + + { + try { + result = picture.SetSize(*(Dali::Vector2 *)pSize); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Picture_GetSize(char *pPicture) { + Dali::CanvasRenderer::Picture picture; + Dali::Vector2 result; + + if (!pPicture) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Picture", 0); + return nullptr; + } + picture = *(Dali::CanvasRenderer::Picture *)pPicture; + + { + try { + result = picture.GetSize(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Vector2((const Dali::Vector2 &)result); +} + +// Dali::CanvasRenderer::Shape Wrapper + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Shape_New() { + Dali::CanvasRenderer::Shape shape; + + { + try { + shape = Dali::CanvasRenderer::Shape::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::CanvasRenderer::Shape( + (const Dali::CanvasRenderer::Shape &)shape); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddRect(char *pShape, float x, + float y, float width, + float height, + float roundX, + float roundY) { + Dali::CanvasRenderer::Shape shape; + bool result = false; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return false; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + result = shape.AddRect(Rect(x, y, width, height), + Vector2(roundX, roundY)); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddCircle(char *pShape, float x, + float y, float radiusX, + float radiusY) { + Dali::CanvasRenderer::Shape shape; + bool result = false; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return false; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + result = shape.AddCircle(Vector2(x, y), Vector2(radiusX, radiusY)); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddArc(char *pShape, float x, + float y, float radius, + float startAngle, + float sweep, bool pie) { + Dali::CanvasRenderer::Shape shape; + bool result = false; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return false; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + result = shape.AddArc(Vector2(x, y), radius, startAngle, sweep, pie); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddMoveTo(char *pShape, float x, + float y) { + Dali::CanvasRenderer::Shape shape; + bool result = false; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return false; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + result = shape.AddMoveTo(Vector2(x, y)); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddLineTo(char *pShape, float x, + float y) { + Dali::CanvasRenderer::Shape shape; + bool result = false; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return false; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + result = shape.AddLineTo(Vector2(x, y)); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddCubicTo( + char *pShape, float controlPoint1X, float controlPoint1Y, + float controlPoint2X, float controlPoint2Y, float endPointX, + float endPointY) { + Dali::CanvasRenderer::Shape shape; + bool result = false; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return false; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + result = shape.AddCubicTo(Vector2(controlPoint1X, controlPoint1Y), + Vector2(controlPoint2X, controlPoint2Y), + Vector2(endPointX, endPointY)); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddPath(char *pShape, + int *pCommands, + unsigned int commandCount, + float *pPoints, + unsigned int pointCount) { + Dali::CanvasRenderer::Shape shape; + bool result = false; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return false; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + if (!pCommands) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Commands", 0); + return false; + } + + if (!pPoints) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, + "Attempt to dereference null Points", + 0); + return false; + } + + { + try { + Dali::CanvasRenderer::Shape::PathCommands pathCommands = { + (Dali::CanvasRenderer::Shape::PathCommandType *)pCommands, + commandCount, pPoints, pointCount}; + + result = shape.AddPath(pathCommands); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_Close(char *pShape) { + Dali::CanvasRenderer::Shape shape; + bool result = false; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return false; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + result = shape.Close(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_ResetPath(char *pShape) { + Dali::CanvasRenderer::Shape shape; + bool result = false; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return false; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + result = shape.ResetPath(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetFillColor(char *pShape, + char *pColor) { + Dali::CanvasRenderer::Shape shape; + Dali::Vector4 color; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + if (!pColor) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, + "Dali::Vector4 const & type is null", + 0); + return; + } + color = *(Dali::Vector4 *)pColor; + + { + try { + shape.SetFillColor(color); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Shape_GetFillColor(char *pShape) { + Dali::CanvasRenderer::Shape shape; + Dali::Vector4 result; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return 0; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + result = shape.GetFillColor(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Vector4((const Dali::Vector4 &)result); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetFillRule(char *pShape, + int rule) { + Dali::CanvasRenderer::Shape shape; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + shape.SetFillRule( + static_cast(rule)); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shape_GetFillRule(char *pShape) { + Dali::CanvasRenderer::Shape shape; + Dali::CanvasRenderer::Shape::FillRule result; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return 0; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + result = shape.GetFillRule(); + } + CALL_CATCH_EXCEPTION(0); + } + + return (int)result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeWidth(char *pShape, + float width) { + Dali::CanvasRenderer::Shape shape; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + shape.SetStrokeWidth(width); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Shape_GetStrokeWidth(char *pShape) { + Dali::CanvasRenderer::Shape shape; + float result; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return 0; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + result = shape.GetStrokeWidth(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeColor(char *pShape, + char *pColor) { + Dali::CanvasRenderer::Shape shape; + Dali::Vector4 color; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + if (!pColor) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, + "Dali::Vector4 const & type is null", + 0); + return; + } + color = *(Dali::Vector4 *)pColor; + { + try { + shape.SetStrokeColor(color); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Shape_GetStrokeColor(char *pShape) { + Dali::CanvasRenderer::Shape shape; + Dali::Vector4 result; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return 0; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + { + try { + result = shape.GetStrokeColor(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Vector4((const Dali::Vector4 &)result); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeDash( + char *pShape, float *pDashPattern, unsigned int patternLength) { + Dali::CanvasRenderer::Shape shape; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + if (!pDashPattern) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, + "Dash pattern is null", 0); + return; + } + + { + try { + Vector dashPattern; + for (unsigned int count = 0; count < patternLength; count++) { + dashPattern.PushBack(pDashPattern[count]); + } + shape.SetStrokeDash(dashPattern); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT unsigned int SWIGSTDCALL +CSharp_Dali_Shape_GetStrokeDashCount(char *pShape) { + Dali::CanvasRenderer::Shape shape; + unsigned int result; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return 0; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + + Dali::Vector dashPattern = shape.GetStrokeDash(); + result = dashPattern.Size(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT float SWIGSTDCALL +CSharp_Dali_Shape_GetStrokeDashIndexOf(char *pShape, unsigned int index) { + Dali::CanvasRenderer::Shape shape; + float result = 0.0f; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return 0; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + Dali::Vector dashPattern = shape.GetStrokeDash(); + if (index >= dashPattern.Size()) { + throw std::invalid_argument("invalid index"); + } + result = dashPattern[index]; + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeCap(char *pShape, + int cap) { + Dali::CanvasRenderer::Shape shape; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + shape.SetStrokeCap( + static_cast(cap)); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shape_GetStrokeCap(char *pShape) { + Dali::CanvasRenderer::Shape shape; + Dali::CanvasRenderer::Shape::StrokeCap result; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return 0; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + result = shape.GetStrokeCap(); + } + CALL_CATCH_EXCEPTION(0); + } + + return (int)result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeJoin(char *pShape, + int join) { + Dali::CanvasRenderer::Shape shape; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + shape.SetStrokeJoin( + static_cast(join)); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shape_GetStrokeJoin(char *pShape) { + Dali::CanvasRenderer::Shape shape; + Dali::CanvasRenderer::Shape::StrokeJoin result; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return 0; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + { + try { + result = shape.GetStrokeJoin(); + } + CALL_CATCH_EXCEPTION(0); + } + + return (int)result; +} + +SWIGEXPORT bool SWIGSTDCALL +CSharp_Dali_Shapep_SetFillGradient(char *pShape, char *pGradient) { + Dali::CanvasRenderer::Shape shape; + Dali::CanvasRenderer::Gradient gradient; + bool result = true; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return false; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + if (!pGradient) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0); + return false; + } + gradient = *(Dali::CanvasRenderer::Gradient *)pGradient; + { + try { + result = shape.SetFillGradient(gradient); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Shapep_GetFillGradient(char *pShape) { + Dali::CanvasRenderer::Shape shape; + Dali::CanvasRenderer::Gradient gradient; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return nullptr; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + gradient = shape.GetFillGradient(); + } + CALL_CATCH_EXCEPTION(nullptr); + } + + return new Dali::CanvasRenderer::Gradient( + (const Dali::CanvasRenderer::Gradient &)gradient); +} + +SWIGEXPORT bool SWIGSTDCALL +CSharp_Dali_Shapep_SetStrokeGradient(char *pShape, char *pGradient) { + Dali::CanvasRenderer::Shape shape; + Dali::CanvasRenderer::Gradient gradient; + bool result = true; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return false; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + if (!pGradient) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0); + return false; + } + gradient = *(Dali::CanvasRenderer::Gradient *)pGradient; + { + try { + shape.SetStrokeGradient(gradient); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void *SWIGSTDCALL +CSharp_Dali_Shapep_GetStrokeGradient(char *pShape) { + Dali::CanvasRenderer::Shape shape; + Dali::CanvasRenderer::Gradient gradient; + + if (!pShape) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); + return nullptr; + } + shape = *(Dali::CanvasRenderer::Shape *)pShape; + + { + try { + gradient = shape.GetStrokeGradient(); + } + CALL_CATCH_EXCEPTION(nullptr); + } + + return new Dali::CanvasRenderer::Gradient( + (const Dali::CanvasRenderer::Gradient &)gradient); +} + +// Dali::CanvasRenderer::DrawableGroup Wrapper + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_DrawableGroup_New() { + Dali::CanvasRenderer::DrawableGroup drawableGroup; + + { + try { + drawableGroup = Dali::CanvasRenderer::DrawableGroup::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::CanvasRenderer::DrawableGroup( + (const Dali::CanvasRenderer::DrawableGroup &)drawableGroup); +} + +SWIGEXPORT bool SWIGSTDCALL +CSharp_Dali_DrawableGroup_AddDrawable(char *pDrawableGroup, char *pDrawable) { + Dali::CanvasRenderer::DrawableGroup drawableGroup; + Dali::CanvasRenderer::Drawable drawable; + bool result = true; + + if (!pDrawableGroup) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::DrawableGroup", 0); + return false; + } + drawableGroup = *(Dali::CanvasRenderer::DrawableGroup *)pDrawableGroup; + + if (!pDrawable) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); + return false; + } + drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; + { + try { + drawableGroup.AddDrawable(drawable); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_DrawableGroup_RemoveDrawable( + char *pDrawableGroup, char *pDrawable) { + Dali::CanvasRenderer::DrawableGroup drawableGroup; + Dali::CanvasRenderer::Drawable drawable; + bool result = true; + + if (!pDrawableGroup) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::DrawableGroup", 0); + return false; + } + drawableGroup = *(Dali::CanvasRenderer::DrawableGroup *)pDrawableGroup; + + if (!pDrawable) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); + return false; + } + drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; + { + try { + drawableGroup.RemoveDrawable(drawable); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL +CSharp_Dali_DrawableGroup_RemoveAllDrawables(char *pDrawableGroup) { + Dali::CanvasRenderer::DrawableGroup drawableGroup; + bool result = false; + + if (!pDrawableGroup) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::DrawableGroup", 0); + return false; + } + drawableGroup = *(Dali::CanvasRenderer::DrawableGroup *)pDrawableGroup; + + { + try { + result = drawableGroup.RemoveAllDrawables(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +// Dali::CanvasRenderer::Gradient Wrapper + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gradient_SetColorStops( + char *pGradient, float *pStops, unsigned int stopsLength) { + Dali::CanvasRenderer::Gradient gradient; + + if (!pGradient) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0); + return; + } + gradient = *(Dali::CanvasRenderer::Gradient *)pGradient; + + if (!pStops) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, + "Stops is null", 0); + return; + } + + { + try { + Dali::CanvasRenderer::Gradient::ColorStops stops; + for (unsigned int count = 0; count < stopsLength; count++) { + Dali::CanvasRenderer::Gradient::ColorStop stop; + stop.offset = pStops[count * 5]; + stop.color = Vector4(pStops[(count * 5) + 1], pStops[(count * 5) + 2], + pStops[(count * 5) + 3], pStops[(count * 5) + 4]); + stops.PushBack(stop); + } + gradient.SetColorStops(stops); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT unsigned int SWIGSTDCALL +CSharp_Dali_Gradient_GetColorStopsCount(char *pGradient) { + Dali::CanvasRenderer::Gradient gradient; + unsigned int result = 0; + + if (!pGradient) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0); + return 0; + } + gradient = *(Dali::CanvasRenderer::Gradient *)pGradient; + + { + try { + Dali::CanvasRenderer::Gradient::ColorStops colorStops = + gradient.GetColorStops(); + result = colorStops.Size(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Gradient_GetColorStopsOffsetIndexOf( + char *pGradient, unsigned int index) { + Dali::CanvasRenderer::Gradient gradient; + float result = 0.0f; + + if (!pGradient) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0); + return 0.0f; + } + gradient = *(Dali::CanvasRenderer::Gradient *)pGradient; + + { + try { + Dali::CanvasRenderer::Gradient::ColorStops colorStops = + gradient.GetColorStops(); + if (index >= colorStops.Size()) { + throw std::invalid_argument("invalid index"); + } + result = colorStops[index].offset; + } + CALL_CATCH_EXCEPTION(0.0f); + } + + return result; +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Gradient_GetColorStopsColorIndexOf( + char *pGradient, unsigned int index) { + Dali::CanvasRenderer::Gradient gradient; + Dali::Vector4 result; + + if (!pGradient) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0); + return nullptr; + } + gradient = *(Dali::CanvasRenderer::Gradient *)pGradient; + + { + try { + Dali::CanvasRenderer::Gradient::ColorStops colorStops = + gradient.GetColorStops(); + if (index >= colorStops.Size()) { + throw std::invalid_argument("invalid index"); + } + result = colorStops[index].color; + } + CALL_CATCH_EXCEPTION(nullptr); + } + + return new Dali::Vector4((const Dali::Vector4 &)result); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gradient_SetSpread(char *pGradient, + int spread) { + Dali::CanvasRenderer::Gradient gradient; + + if (!pGradient) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0); + return; + } + gradient = *(Dali::CanvasRenderer::Gradient *)pGradient; + + { + try { + gradient.SetSpread( + static_cast(spread)); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gradient_GetSpread(char *pGradient) { + Dali::CanvasRenderer::Gradient gradient; + Dali::CanvasRenderer::Gradient::Spread result; + + if (!pGradient) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0); + return 0; + } + gradient = *(Dali::CanvasRenderer::Gradient *)pGradient; + + { + try { + result = gradient.GetSpread(); + } + CALL_CATCH_EXCEPTION(0); + } + + return (int)result; +} + +// Dali::CanvasRenderer::LinearGradient Wrapper + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_LinearGradient_New() { + Dali::CanvasRenderer::LinearGradient linearGradient; + + { + try { + linearGradient = Dali::CanvasRenderer::LinearGradient::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::CanvasRenderer::LinearGradient( + (const Dali::CanvasRenderer::LinearGradient &)linearGradient); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LinearGradient_SetBounds( + char *pLinearGradient, void *pFirstPoint, void *pSecondPoint) { + Dali::CanvasRenderer::LinearGradient linearGradient; + bool result = false; + + if (!pLinearGradient) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::LinearGradient", 0); + return false; + } + linearGradient = *(Dali::CanvasRenderer::LinearGradient *)pLinearGradient; + + if (!pFirstPoint) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::Vector2", 0); + return false; + } + + if (!pSecondPoint) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::Vector2", 0); + return false; + } + + { + try { + result = linearGradient.SetBounds(*(Dali::Vector2 *)pFirstPoint, + *(Dali::Vector2 *)pSecondPoint); + } + CALL_CATCH_EXCEPTION(false); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LinearGradient_GetBounds( + char *pLinearGradient, void *pFirstPoint, void *pSecondPoint) { + Dali::CanvasRenderer::LinearGradient linearGradient; + bool result = false; + + if (!pLinearGradient) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::LinearGradient", 0); + return false; + } + linearGradient = *(Dali::CanvasRenderer::LinearGradient *)pLinearGradient; + + if (!pFirstPoint) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::Vector2", 0); + return false; + } + + if (!pSecondPoint) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::Vector2", 0); + return false; + } + + { + try { + result = linearGradient.GetBounds(*(Dali::Vector2 *)pFirstPoint, + *(Dali::Vector2 *)pSecondPoint); + } + CALL_CATCH_EXCEPTION(false); + } + return result; +} + +// Dali::CanvasRenderer::RadialGradient Wrapper + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_RadialGradient_New() { + Dali::CanvasRenderer::RadialGradient radialGradient; + + { + try { + radialGradient = Dali::CanvasRenderer::RadialGradient::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::CanvasRenderer::RadialGradient( + (const Dali::CanvasRenderer::RadialGradient &)radialGradient); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RadialGradient_SetBounds( + char *pRadialGradient, void *pCenterPoint, float radius) { + Dali::CanvasRenderer::RadialGradient radialGradient; + bool result = false; + + if (!pRadialGradient) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::RadialGradient", 0); + return false; + } + radialGradient = *(Dali::CanvasRenderer::RadialGradient *)pRadialGradient; + + if (!pCenterPoint) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::Vector2", 0); + return false; + } + + { + try { + result = radialGradient.SetBounds(*(Dali::Vector2 *)pCenterPoint, radius); + } + CALL_CATCH_EXCEPTION(false); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RadialGradient_GetBounds( + char *pRadialGradient, void *pCenterPoint, void *radius) { + Dali::CanvasRenderer::RadialGradient radialGradient; + bool result = false; + + if (!pRadialGradient) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::CanvasRenderer::RadialGradient", 0); + return false; + } + radialGradient = *(Dali::CanvasRenderer::RadialGradient *)pRadialGradient; + + if (!pCenterPoint) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::Vector2", 0); + return false; + } + + { + try { + result = radialGradient.GetBounds(*(Dali::Vector2 *)pCenterPoint, + *(float *)radius); + } + CALL_CATCH_EXCEPTION(false); + } + return result; +} +#ifdef __cplusplus +} // end extern "C" +#endif diff --git a/dali-csharp-binder/dali-toolkit/control-devel-wrap.cpp b/dali-csharp-binder/dali-toolkit/control-devel-wrap.cpp new file mode 100644 index 00000000..53fcab31 --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/control-devel-wrap.cpp @@ -0,0 +1,593 @@ +/* + * Copyright (c) 2022 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include "control-devel-wrap.h" +#include +#include +#include +#include +#include +#include +#include + +using namespace Dali; +using namespace Dali::Toolkit; +using namespace Dali::Toolkit::DevelControl; + +namespace +{ +typedef void (*SavedCallbackType)(int32_t, int32_t, uint32_t, float *val1, float *val2, float *val3); +SavedCallbackType gSavedRootCallback = nullptr; + +Dali::Property::Value RootCallback(int32_t id, VectorAnimationRenderer::VectorProperty property, uint32_t frameNumber) +{ + float val1 = 0.0f, val2 = 0.0f, val3 = 0.0f; + if(gSavedRootCallback != nullptr) + { + gSavedRootCallback(id, (int)property, frameNumber, &val1, &val2, &val3); + } + + switch(property) + { + case VectorAnimationRenderer::VectorProperty::FILL_COLOR : + case VectorAnimationRenderer::VectorProperty::STROKE_COLOR : + return Dali::Vector3(val1, val2, val3); + break; + + case VectorAnimationRenderer::VectorProperty::TRANSFORM_ANCHOR : + case VectorAnimationRenderer::VectorProperty::TRANSFORM_POSITION : + case VectorAnimationRenderer::VectorProperty::TRANSFORM_SCALE : + return Dali::Vector2(val1, val2); + break; + + case VectorAnimationRenderer::VectorProperty::FILL_OPACITY : + case VectorAnimationRenderer::VectorProperty::STROKE_OPACITY : + case VectorAnimationRenderer::VectorProperty::STROKE_WIDTH : + case VectorAnimationRenderer::VectorProperty::TRANSFORM_ROTATION : + case VectorAnimationRenderer::VectorProperty::TRANSFORM_OPACITY : + return val1; + break; + + default: + return 0; + break; + } +} +} //unnamed namespace + +#ifdef __cplusplus +extern "C" { +#endif + +// property +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_DISPATCH_KEY_EVENTS_get() +{ + return (int)Dali::Toolkit::DevelControl::Property::DISPATCH_KEY_EVENTS; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityActivateSignal(void* arg1) +{ + Dali::Toolkit::DevelControl::AccessibilityActivateSignalType* result = nullptr; + GUARD_ON_NULL_RET0(arg1); + try_catch(([&]() { + Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1; + result = &(AccessibilityActivateSignal(*control)); + })); + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityReadingSkippedSignal(void* arg1) +{ + Dali::Toolkit::DevelControl::AccessibilityReadingSkippedSignalType* result = nullptr; + GUARD_ON_NULL_RET0(arg1); + try_catch(([&]() { + Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1; + result = &(AccessibilityReadingSkippedSignal(*control)); + })); + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityReadingPausedSignal(void* arg1) +{ + Dali::Toolkit::DevelControl::AccessibilityReadingPausedSignalType* result = nullptr; + GUARD_ON_NULL_RET0(arg1); + try_catch(([&]() { + Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1; + result = &(AccessibilityReadingPausedSignal(*control)); + })); + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityReadingResumedSignal(void* arg1) +{ + Dali::Toolkit::DevelControl::AccessibilityReadingResumedSignalType* result = nullptr; + GUARD_ON_NULL_RET0(arg1); + try_catch(([&]() { + Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1; + result = &(AccessibilityReadingResumedSignal(*control)); + })); + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityReadingCancelledSignal(void* arg1) +{ + Dali::Toolkit::DevelControl::AccessibilityReadingCancelledSignalType* result = nullptr; + GUARD_ON_NULL_RET0(arg1); + try_catch(([&]() { + Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1; + result = &(AccessibilityReadingCancelledSignal(*control)); + })); + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityReadingStoppedSignal(void* arg1) +{ + Dali::Toolkit::DevelControl::AccessibilityReadingStoppedSignalType* result = nullptr; + GUARD_ON_NULL_RET0(arg1); + try_catch(([&]() { + Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1; + result = &(AccessibilityReadingStoppedSignal(*control)); + })); + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityGetNameSignal(void* arg1) +{ + Dali::Toolkit::DevelControl::AccessibilityGetNameSignalType* result = nullptr; + GUARD_ON_NULL_RET0(arg1); + try_catch(([&]() { + Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1; + result = &(AccessibilityGetNameSignal(*control)); + })); + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityGetDescriptionSignal(void* arg1) +{ + Dali::Toolkit::DevelControl::AccessibilityGetDescriptionSignalType* result = nullptr; + GUARD_ON_NULL_RET0(arg1); + try_catch(([&]() { + Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1; + result = &(AccessibilityGetDescriptionSignal(*control)); + })); + return (void*)result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityDoGestureSignal(void* arg1) +{ + Dali::Toolkit::DevelControl::AccessibilityDoGestureSignalType* result = nullptr; + GUARD_ON_NULL_RET0(arg1); + try_catch(([&]() { + Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1; + result = &(AccessibilityDoGestureSignal(*control)); + })); + return (void*)result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AppendAccessibilityRelation(void* arg1, void* arg2, int arg3) +{ + GUARD_ON_NULL_RET(arg1); + GUARD_ON_NULL_RET(arg2); + try_catch(([&]() { + auto* control = (Dali::Toolkit::Control*)arg1; + auto* destination = (Dali::Actor*)arg2; + auto relation = (Dali::Accessibility::RelationType)arg3; + AppendAccessibilityRelation(*control, *destination, relation); + })); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_RemoveAccessibilityRelation(void* arg1, void* arg2, int arg3) +{ + GUARD_ON_NULL_RET(arg1); + GUARD_ON_NULL_RET(arg2); + try_catch(([&]() { + auto* control = (Dali::Toolkit::Control*)arg1; + auto* destination = (Dali::Actor*)arg2; + auto relation = (Dali::Accessibility::RelationType)arg3; + RemoveAccessibilityRelation(*control, *destination, relation); + })); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_GetAccessibilityRelations(void* arg1_control, + void (*arg2_callback)(int, void*, void*), + void* arg3_userData) +{ + using namespace Dali::Accessibility; + + GUARD_ON_NULL_RET(arg1_control); + GUARD_ON_NULL_RET(arg2_callback); + + try_catch(([&]() { + auto* control = static_cast(arg1_control); + std::vector relations = GetAccessibilityRelations(*control); + + for(Relation& relation : relations) + { + for(Accessible* target : relation.mTargets) + { + // NUI is unaware of Accessible objects, so we only report those + // convertible to Control. Note that it is currently impossible to make + // a relation with anything other than Control (View) using NUI API, so + // there should not be any loss of information for typical NUI + // applications. + auto targetControl = Dali::Toolkit::Control::DownCast(target->GetInternalActor()); + + if(targetControl) + { + arg2_callback(static_cast(relation.mRelationType), + static_cast(new Dali::Actor(targetControl)), + arg3_userData); + } + } + } + })); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_ClearAccessibilityRelations(void* arg1) +{ + GUARD_ON_NULL_RET(arg1); + try_catch(([&]() { + auto* control = (Dali::Toolkit::Control*)arg1; + ClearAccessibilityRelations(*control); + })); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_SetAccessibilityReadingInfoType2(void* arg1, int arg2) +{ + using namespace Dali::Accessibility; + static_assert(static_cast(ReadingInfoType::NAME) == 0 && + static_cast(ReadingInfoType::ROLE) == 1 && + static_cast(ReadingInfoType::DESCRIPTION) == 2 && + static_cast(ReadingInfoType::STATE) == 3, + "C++ and C# bindings does not match"); + + GUARD_ON_NULL_RET(arg1); + try_catch(([&]() { + auto* control = (Dali::Toolkit::Control*)arg1; + SetAccessibilityReadingInfoType(*control, ReadingInfoTypes{static_cast(arg2)}); + })); +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_GetAccessibilityReadingInfoType2(void* arg1) +{ + int result = 0; + GUARD_ON_NULL_RET0(arg1); + try_catch(([&]() { + auto* control = (Dali::Toolkit::Control*)arg1; + auto readingInfo = GetAccessibilityReadingInfoType(*control); + result = readingInfo.GetRawData()[0]; + })); + return result; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_ClearAccessibilityHighlight(void* arg1) +{ + bool result = false; + GUARD_ON_NULL_RET0(arg1); + try_catch(([&]() { + auto* control = (Dali::Toolkit::Control*)arg1; + result = ClearAccessibilityHighlight(*control); + })); + return result; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_GrabAccessibilityHighlight(void* arg1) +{ + bool result = false; + GUARD_ON_NULL_RET0(arg1); + try_catch(([&]() { + auto* control = (Dali::Toolkit::Control*)arg1; + result = GrabAccessibilityHighlight(*control); + })); + return result; +} + +SWIGEXPORT uint64_t SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_GetAccessibilityStates(void* arg1) +{ + uint64_t result = 0; + GUARD_ON_NULL_RET0(arg1); + try_catch(([&]() { + auto* control = (Dali::Toolkit::Control*)arg1; + auto states = GetAccessibilityStates(*control); + result = states.GetRawData64(); + })); + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_NotifyAccessibilityStateChange(void* arg1, uint64_t arg2, int arg3) +{ + GUARD_ON_NULL_RET(arg1); + try_catch(([&]() { + Dali::Accessibility::States states(arg2); + auto* control = (Dali::Toolkit::Control*)arg1; + NotifyAccessibilityStateChange(*control, states, static_cast(arg3)); + })); +} + +/*********************************************** + **************** Accessibility **************** + ***********************************************/ + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_EmitAccessibilityEvent(void* arg1, int arg2_event) +{ + GUARD_ON_NULL_RET(arg1); + try_catch(([&]() { + Dali::Actor* control = (Dali::Actor*)arg1; + auto accessible = Dali::Accessibility::Accessible::Get(*control); + if(accessible) + { + accessible->Emit((Dali::Accessibility::ObjectPropertyChangeEvent)arg2_event); + } + else + { + SWIG_CSharpException(SWIG_RuntimeError, "Actor does not have accessible object."); + } + })); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_EmitAccessibilityStateChangedEvent(void* arg1, int arg2_state, int arg3) +{ + GUARD_ON_NULL_RET(arg1); + try_catch(([&]() { + auto state = static_cast(arg2_state); + + Dali::Actor* control = (Dali::Actor*)arg1; + auto accessible = Dali::Accessibility::Accessible::Get(*control); + if(accessible) + { + accessible->EmitStateChanged(state, arg3); + } + else + { + SWIG_CSharpException(SWIG_RuntimeError, "Actor does not have accessible object."); + } + })); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_EmitTextInsertedEvent( + void* arg1, int arg2_position, int arg3_length, char* arg4_content) +{ + GUARD_ON_NULL_RET(arg1); + try_catch(([&]() { + Dali::Actor* control = (Dali::Actor*)arg1; + auto accessible = Dali::Accessibility::Accessible::Get(*control); + std::string content(arg4_content ? arg4_content : ""); + if(accessible) + { + accessible->EmitTextInserted(arg2_position, arg3_length, content); + } + else + { + SWIG_CSharpException(SWIG_RuntimeError, "Actor does not have accessible object."); + } + })); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_EmitTextDeletedEvent( + void* arg1, int arg2_position, int arg3_length, char* arg4_content) +{ + GUARD_ON_NULL_RET(arg1); + try_catch(([&]() { + Dali::Actor* control = (Dali::Actor*)arg1; + auto accessible = Dali::Accessibility::Accessible::Get(*control); + std::string content(arg4_content ? arg4_content : ""); + if(accessible) + { + accessible->EmitTextDeleted(arg2_position, arg3_length, content); + } + else + { + SWIG_CSharpException(SWIG_RuntimeError, "Actor does not have accessible object."); + } + })); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_EmitTextCursorMovedEvent( + void* arg1, int arg2_position) +{ + GUARD_ON_NULL_RET(arg1); + try_catch(([&]() { + Dali::Actor* control = (Dali::Actor*)arg1; + auto accessible = Dali::Accessibility::Accessible::Get(*control); + if(accessible) + { + accessible->EmitTextCursorMoved(arg2_position); + } + else + { + SWIG_CSharpException(SWIG_RuntimeError, "Actor does not have accessible object."); + } + })); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_EmitScrollStartedEvent(void* arg1_actor) +{ + GUARD_ON_NULL_RET(arg1_actor); + try_catch(([&]() { + Dali::Actor* control = (Dali::Actor*)arg1_actor; + auto accessible = Dali::Accessibility::Accessible::Get(*control); + if(accessible) + { + accessible->EmitScrollStarted(); + } + else + { + SWIG_CSharpException(SWIG_RuntimeError, "Actor does not have accessible object."); + } + })); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_EmitScrollFinishedEvent(void* arg1_actor) +{ + GUARD_ON_NULL_RET(arg1_actor); + try_catch(([&]() { + Dali::Actor* control = (Dali::Actor*)arg1_actor; + auto accessible = Dali::Accessibility::Accessible::Get(*control); + if(accessible) + { + accessible->EmitScrollFinished(); + } + else + { + SWIG_CSharpException(SWIG_RuntimeError, "Actor does not have accessible object."); + } + })); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Accessibility_IsSuppressedEvent(void* arg1, int32_t atspiEvent) +{ + bool result = false; + GUARD_ON_NULL_RET0(arg1); + try_catch(([&]() { + Dali::Actor* control = (Dali::Actor*)arg1; + auto accessible = Dali::Accessibility::Accessible::Get(*control); + if(accessible) + { + result = accessible->GetSuppressedEvents()[static_cast(atspiEvent)]; + } + })); + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_SetSuppressedEvent(void* arg1, int32_t atspiEvent, bool isSuppressed) +{ + GUARD_ON_NULL_RET(arg1); + try_catch(([&]() { + Dali::Actor* control = (Dali::Actor*)arg1; + auto accessible = Dali::Accessibility::Accessible::Get(*control); + if(accessible) + { + accessible->GetSuppressedEvents()[static_cast(atspiEvent)] = isSuppressed; + } + })); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Accessibility_new_Range( + int arg1_start, int arg2_end, char* arg3_content) +{ + Dali::Accessibility::Range* result = nullptr; + try_catch(([&]() { + result = new Dali::Accessibility::Range(arg1_start, arg2_end, arg3_content); + })); + return (void*)result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_delete_Range(void* arg1_range) +{ + try_catch(([&]() { + delete static_cast(arg1_range); + })); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_Bridge_RegisterDefaultLabel(void* arg1_actor) +{ + GUARD_ON_NULL_RET(arg1_actor); + try_catch(([&]() { + Dali::Actor* actor = (Dali::Actor*)arg1_actor; + auto accessible = Dali::Accessibility::Accessible::Get(*actor); + auto bridge = Dali::Accessibility::Bridge::GetCurrentBridge(); + + if(!accessible) + { + SWIG_CSharpException(SWIG_RuntimeError, "No accessible object bind with actor."); + return; + } + + bridge->RegisterDefaultLabel(accessible); + })); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_Bridge_UnregisterDefaultLabel(void* arg1_actor) +{ + GUARD_ON_NULL_RET(arg1_actor); + try_catch(([&]() { + Dali::Actor* actor = (Dali::Actor*)arg1_actor; + auto accessible = Dali::Accessibility::Accessible::Get(*actor); + auto bridge = Dali::Accessibility::Bridge::GetCurrentBridge(); + + if(!accessible) + { + SWIG_CSharpException(SWIG_RuntimeError, "No accessible object bind with actor."); + return; + } + + bridge->UnregisterDefaultLabel(accessible); + })); +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Accessibility_Accessible_GetCurrentlyHighlightedActor() +{ + Dali::Actor* result = NULL; + try_catch(([&]() { + Dali::Actor actor = Dali::Accessibility::Accessible::GetCurrentlyHighlightedActor(); + if(actor) + { + result = new Dali::Actor(actor); + } + })); + return result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Accessibility_Accessible_GetHighlightActor() +{ + Dali::Actor* result = NULL; + try_catch(([&]() { + Dali::Actor actor = Dali::Accessibility::Accessible::GetHighlightActor(); + if(actor) + { + result = new Dali::Actor(actor); + } + })); + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_Accessible_SetHighlightActor(void* arg1_actor) +{ + // Passing nullptr as actor is used to remove custom highlight, + // what leads to the restoration of default highlight starting + // from next call to GrabHighlight() + try_catch(([&]() { + Dali::Actor actor = arg1_actor ? *((Dali::Actor*)arg1_actor) : Dali::Actor(); + Dali::Accessibility::Accessible::SetHighlightActor(actor); + })); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoActionExtension(void * control, int visualIndex, int actionId, int callbackId, char* keyPath, int property, void * callback) +{ + DevelAnimatedVectorImageVisual::DynamicPropertyInfo info; + info.id = callbackId; + std::string path(keyPath); + info.keyPath = path; + info.property = property; + gSavedRootCallback = (void (*)(int32_t, int32_t, uint32_t, float *val1, float *val2, float *val3))callback; + info.callback = Dali::MakeCallback((Dali::Property::Value (*)(int32_t, int32_t, uint32_t))RootCallback); + + try + { + DevelControl::DoActionExtension(*((Dali::Toolkit::Control *)control), (Dali::Property::Index)visualIndex, (Dali::Property::Index)actionId, Dali::Any(info)); + } CALL_CATCH_EXCEPTION(); +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/dali-csharp-binder/dali-toolkit/control-devel-wrap.h b/dali-csharp-binder/dali-toolkit/control-devel-wrap.h new file mode 100644 index 00000000..6ca25496 --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/control-devel-wrap.h @@ -0,0 +1,32 @@ +#ifndef CONTROL_DEVEL_WRAP_H +#define CONTROL_DEVEL_WRAP_H + +/* + * Copyright (c) 2021 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +/* Callback for returning strings to C# without leaking memory */ +typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +#endif // CONTROL_DEVEL_WRAP_H + diff --git a/dali-csharp-binder/dali-toolkit/dali-toolkit-wrap.cpp b/dali-csharp-binder/dali-toolkit/dali-toolkit-wrap.cpp new file mode 100644 index 00000000..69d67d88 --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/dali-toolkit-wrap.cpp @@ -0,0 +1,17499 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include + +#include + +// INTERNAL INCLUDES +#include +#include + +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +// SWIGINTERN - the relevant parts of the generated code can be seen the below. + +SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)) +{ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)) +{ + self->Disconnect( func ); +} +SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg) +{ + return self->Emit( arg ); +} +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) +{ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) +{ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2) +{ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg1, arg2 ); +} +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) +{ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) +{ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2) +{ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg1, arg2 ); +} +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)) +{ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)) +{ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg) +{ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg ); +} +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)) +{ + return self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)) +{ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3) +{ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg1, arg2, arg3 ); +} +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)) +{ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)) +{ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg) +{ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg ); +} +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)) +{ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)) +{ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg) +{ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg ); +} +SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)) +{ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)) +{ + self->Disconnect( func ); +} +SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2) +{ + return self->Emit( arg1, arg2 ); +} +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)) +{ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)) +{ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg) +{ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg ); +} +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self) +{ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self) +{ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)) +{ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)) +{ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg) +{ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg ); +} + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){ + return self->Empty(); + } +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){ + return self->GetConnectionCount(); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){ + self->Connect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){ + self->Disconnect( func ); + } +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){ + /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; +/*@SWIG@*/ self->Emit( arg ); + } + + +using namespace Dali; +using namespace Dali::Toolkit; + +#ifdef __cplusplus +extern "C" { +#endif + + +// Property + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Visual::Property::TYPE; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Visual::Property::SHADER; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::BorderVisual::Property::COLOR; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::BorderVisual::Property::SIZE; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::GradientVisual::Property::CENTER; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::GradientVisual::Property::UNITS; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::ImageVisual::Property::URL; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() { + int jresult ; + int result; + { + try + { + result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() { + int jresult ; + int result; + { + try + { + result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() { + int jresult ; + int result; + { + try + { + result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() { + return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() { + int jresult ; + int result; + { + try + { + result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() { + int jresult ; + int result; + { + try + { + result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() { + int jresult ; + int result; + { + try + { + result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() { + int jresult ; + int result; + { + try + { + result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() { + int jresult ; + int result; + { + try + { + result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() { + int jresult ; + int result; + { + try + { + result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() { + int jresult ; + int result; + { + try + { + result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +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; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::ImageVisual::Property::BORDER; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE; + } CALL_CATCH_EXCEPTION(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; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS; + } CALL_CATCH_EXCEPTION(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; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::TextVisual::Property::TEXT; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Tooltip::Property::CONTENT; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Tooltip::Property::TAIL; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Tooltip::Property::POSITION; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() { + int jresult ; + int result; + + { + try { + result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL; + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Control::Property::STYLE_NAME; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Control::Property::BACKGROUND; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Control::Property::MARGIN; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Control::Property::PADDING; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelControl::Property::SHADOW; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_NAME_get() { + return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_NAME; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_DESCRIPTION_get() { + return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_DESCRIPTION; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_TRANSLATION_DOMAIN_get() { + return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_TRANSLATION_DOMAIN; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_ROLE_get() { + return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_ROLE; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_HIGHLIGHTABLE_get() { + return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_ATTRIBUTES_get() { + return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_HIDDEN_get() { + return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_HIDDEN; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_AUTOMATION_ID_get() { + return (int)Dali::Toolkit::DevelControl::Property::AUTOMATION_ID; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() { + void * jresult ; + Dali::Toolkit::FlexContainer::Property *result = 0 ; + + { + try { + result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) { + Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ; + + arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ImageView::Property::IMAGE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PLACEHOLDER_IMAGE_get() { + int jresult; + int result; + result = (int)Dali::Toolkit::ImageView::Property::PLACEHOLDER_IMAGE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_TRANSITION_EFFECT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ImageView::Property::ENABLE_TRANSITION_EFFECT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::WRAP; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::PANNING; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TableView::Property::ROWS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TableView::Property::COLUMNS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() { + unsigned int jresult ; + unsigned int result; + + result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND; + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::TEXT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::SHADOW; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::VideoView::Property::VIDEO; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::VideoView::Property::LOOPING; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::VideoView::Property::MUTED; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::VideoView::Property::VOLUME; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() { + int result; + + result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY; + + return result; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT; + jresult = (int)result; + return jresult; +} + + +// Method + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() { + void * jresult ; + Dali::Toolkit::Builder *result = 0 ; + + { + try { + result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() { + void * jresult ; + Dali::Toolkit::Builder result; + + { + try { + result = Dali::Toolkit::Builder::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) { + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) { + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + std::string *arg2 = 0 ; + Dali::Toolkit::Builder::UIFormat arg3 ; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3; + { + try { + (arg1)->LoadFromString((std::string const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) { + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + (arg1)->LoadFromString((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) { + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + Dali::Property::Map *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + arg2 = (Dali::Property::Map *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); + return ; + } + { + try { + (arg1)->AddConstants((Dali::Property::Map const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) { + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + std::string *arg2 = 0 ; + Dali::Property::Value *arg3 = 0 ; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Property::Value *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); + return ; + } + { + try { + (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) { + void * jresult ; + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + Dali::Property::Map *result = 0 ; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + { + try { + result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) { + void * jresult ; + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + std::string *arg2 = 0 ; + Dali::Property::Value *result = 0 ; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) { + void * jresult ; + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + std::string *arg2 = 0 ; + Dali::Animation result; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + result = (arg1)->CreateAnimation((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Animation((const Dali::Animation &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) { + void * jresult ; + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + std::string *arg2 = 0 ; + Dali::Property::Map *arg3 = 0 ; + Dali::Animation result; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Property::Map *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); + return 0; + } + { + try { + result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Animation((const Dali::Animation &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) { + void * jresult ; + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + std::string *arg2 = 0 ; + Dali::Actor arg3 ; + Dali::Actor *argp3 ; + Dali::Animation result; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + argp3 = (Dali::Actor *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg3 = *argp3; + { + try { + result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Animation((const Dali::Animation &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) { + void * jresult ; + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + std::string *arg2 = 0 ; + Dali::Property::Map *arg3 = 0 ; + Dali::Actor arg4 ; + Dali::Actor *argp4 ; + Dali::Animation result; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Property::Map *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); + return 0; + } + argp4 = (Dali::Actor *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg4 = *argp4; + { + try { + result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Animation((const Dali::Animation &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) { + void * jresult ; + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + std::string *arg2 = 0 ; + Dali::BaseHandle result; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + result = (arg1)->Create((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) { + void * jresult ; + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + std::string *arg2 = 0 ; + Dali::Property::Map *arg3 = 0 ; + Dali::BaseHandle result; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Property::Map *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); + return 0; + } + { + try { + result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) { + void * jresult ; + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + std::string *arg2 = 0 ; + Dali::BaseHandle result; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + result = (arg1)->CreateFromJson((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) { + bool jresult ; + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + std::string *arg2 = 0 ; + Dali::Handle *arg3 = 0 ; + bool result; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Handle *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); + return 0; + } + { + try { + result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) { + bool jresult ; + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + Dali::Handle *arg2 = 0 ; + std::string *arg3 = 0 ; + bool result; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + arg2 = (Dali::Handle *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); + return 0; + } + if (!jarg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg3_str(jarg3); + arg3 = &arg3_str; + { + try { + result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) { + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->AddActors(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) { + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + std::string *arg2 = 0 ; + Dali::Actor arg3 ; + Dali::Actor *argp3 ; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + argp3 = (Dali::Actor *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg3 = *argp3; + { + try { + (arg1)->AddActors((std::string const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) { + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + (arg1)->CreateRenderTask((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) { + void * jresult ; + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + std::string *arg2 = 0 ; + Dali::Path result; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + result = (arg1)->GetPath((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Path((const Dali::Path &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) { + void * jresult ; + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + std::string *arg2 = 0 ; + Dali::PathConstrainer result; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + result = (arg1)->GetPathConstrainer((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) { + void * jresult ; + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + std::string *arg2 = 0 ; + Dali::LinearConstrainer result; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + result = (arg1)->GetLinearConstrainer((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; + Dali::Toolkit::Builder::BuilderSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::Builder *)jarg1; + { + try { + result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +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(); + } CALL_CATCH_EXCEPTION(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; + } CALL_CATCH_EXCEPTION(); + } + +} + + +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); + } CALL_CATCH_EXCEPTION(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); + } CALL_CATCH_EXCEPTION(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); + } CALL_CATCH_EXCEPTION(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); + } CALL_CATCH_EXCEPTION(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); + } CALL_CATCH_EXCEPTION(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(); + } CALL_CATCH_EXCEPTION(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); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Property::Map((const Dali::Property::Map &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() { + void * jresult ; + Dali::Toolkit::Control result; + + { + try { + result = Dali::Toolkit::Internal::Control::New(Dali::Toolkit::Internal::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + (arg1)->SetStyleName((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + + + //argout typemap for const std::string& + +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) { + char * jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + std::string *result = 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Vector4 *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) { + void * jresult ; + Dali::Handle *arg1 = (Dali::Handle *) 0 ; + Dali::Vector4 result; + + arg1 = (Dali::Handle *)jarg1; + { + try { + Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap(); + if (resultMap) + { + Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE ); + if(type && type->Get() == Visual::COLOR ) + { + Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR ); + if (value) + { + result = value->Get(); + } + } + } + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Property::Map *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::Property::Map *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); + return ; + } + { + try { + (arg1)->SetBackground((Dali::Property::Map const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + (arg1)->ClearBackground(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::GestureType::Value arg2 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::GestureType::Value)jarg2; + { + try { + (arg1)->EnableGestureDetection(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::GestureType::Value arg2 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::GestureType::Value)jarg2; + { + try { + (arg1)->DisableGestureDetection(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::PinchGestureDetector result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::PanGestureDetector result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::TapGestureDetector result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::LongPressGestureDetector result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, bool jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + bool arg2 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->SetKeyboardNavigationSupport(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) { + bool jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + result = (bool)(arg1)->IsKeyboardNavigationSupported(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + (arg1)->SetKeyInputFocus(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) { + bool jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + result = (bool)(arg1)->HasKeyInputFocus(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + (arg1)->ClearKeyInputFocus(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, bool jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + bool arg2 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->SetAsKeyboardFocusGroup(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) { + bool jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + result = (bool)(arg1)->IsKeyboardFocusGroup(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + (arg1)->OnInitialize(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + (arg1)->Dali::Toolkit::Internal::Control::OnInitialize(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Toolkit::StyleManager arg2 ; + Dali::StyleChange::Type arg3 ; + Dali::Toolkit::StyleManager *argp2 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + argp2 = (Dali::Toolkit::StyleManager *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::StyleChange::Type)jarg3; + { + try { + (arg1)->OnStyleChange(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Toolkit::StyleManager arg2 ; + Dali::StyleChange::Type arg3 ; + Dali::Toolkit::StyleManager *argp2 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + argp2 = (Dali::Toolkit::StyleManager *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::StyleChange::Type)jarg3; + { + try { + (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) { + bool jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + result = (bool)(arg1)->OnAccessibilityActivated(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) { + bool jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::PanGesture arg2 ; + Dali::PanGesture *argp2 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + argp2 = (Dali::PanGesture *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)(arg1)->OnAccessibilityPan(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::PanGesture arg2 ; + Dali::PanGesture *argp2 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + argp2 = (Dali::PanGesture *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, bool jarg2) { + bool jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + bool arg2 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + result = (bool)(arg1)->OnAccessibilityValueChange(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, bool jarg2) { + bool jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + bool arg2 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) { + bool jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + result = (bool)(arg1)->OnAccessibilityZoom(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) { + bool jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + (arg1)->OnKeyInputFocusGained(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + (arg1)->OnKeyInputFocusLost(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, bool jarg4) { + void * jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Actor arg2 ; + Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ; + bool arg4 ; + Dali::Actor *argp2 ; + Dali::Actor result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg2 = *argp2; + arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3; + arg4 = jarg4 ? true : false; + { + try { + result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, bool jarg4) { + void * jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Actor arg2 ; + Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ; + bool arg4 ; + Dali::Actor *argp2 ; + Dali::Actor result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg2 = *argp2; + arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3; + arg4 = jarg4 ? true : false; + { + try { + result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->OnKeyboardFocusChangeCommitted(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) { + bool jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + result = (bool)(arg1)->OnKeyboardEnter(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) { + bool jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::PinchGesture *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::PinchGesture *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0); + return ; + } + { + try { + (arg1)->OnPinch((Dali::PinchGesture const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::PinchGesture *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::PinchGesture *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0); + return ; + } + { + try { + (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::PanGesture *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::PanGesture *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0); + return ; + } + { + try { + (arg1)->OnPan((Dali::PanGesture const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::PanGesture *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::PanGesture *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0); + return ; + } + { + try { + (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::TapGesture *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::TapGesture *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0); + return ; + } + { + try { + (arg1)->OnTap((Dali::TapGesture const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::TapGesture *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::TapGesture *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0); + return ; + } + { + try { + (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::LongPressGesture *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::LongPressGesture *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0); + return ; + } + { + try { + (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::LongPressGesture *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::LongPressGesture *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0); + return ; + } + { + try { + (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; + Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::SlotObserver *)jarg2; + arg3 = (Dali::CallbackBase *)jarg3; + { + try { + (arg1)->SignalConnected(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; + Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::SlotObserver *)jarg2; + arg3 = (Dali::CallbackBase *)jarg3; + { + try { + (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; + Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::SlotObserver *)jarg2; + arg3 = (Dali::CallbackBase *)jarg3; + { + try { + (arg1)->SignalDisconnected(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) { + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; + Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + arg2 = (Dali::SlotObserver *)jarg2; + arg3 = (Dali::CallbackBase *)jarg3; + { + try { + (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) { + void * jresult ; + Dali::Toolkit::Control *arg1 = 0 ; + Dali::Toolkit::Internal::Control *result = 0 ; + + arg1 = (Dali::Toolkit::Control *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() { + void * jresult ; + Dali::Toolkit::Control::Property *result = 0 ; + + { + try { + result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) { + Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ; + + arg1 = (Dali::Toolkit::Control::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() { + void * jresult ; + Dali::Toolkit::Control::KeyboardFocus *result = 0 ; + + { + try { + result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) { + Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ; + + arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() { + void * jresult ; + Dali::Toolkit::Control result; + + { + try { + result = Dali::Toolkit::Control::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_NewCustom() { + void * jresult; + Dali::Toolkit::Control result; + + { + try { + result = SlimCustomViewImpl::New(Dali::Toolkit::Internal::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() { + void * jresult ; + Dali::Toolkit::Control *result = 0 ; + + { + try { + result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::Control *arg1 = 0 ; + Dali::Toolkit::Control *result = 0 ; + + arg1 = (Dali::Toolkit::Control *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) { + Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; + + arg1 = (Dali::Toolkit::Control *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; + Dali::Toolkit::Control *arg2 = 0 ; + Dali::Toolkit::Control *result = 0 ; + + arg1 = (Dali::Toolkit::Control *)jarg1; + arg2 = (Dali::Toolkit::Control *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::Control 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::Control::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Control(void * jarg1) { + Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) jarg1; + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) { + Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; + + arg1 = (Dali::Toolkit::Control *)jarg1; + { + try { + (arg1)->SetKeyInputFocus(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) { + bool jresult ; + Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::Control *)jarg1; + { + try { + result = (bool)(arg1)->HasKeyInputFocus(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) { + Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; + + arg1 = (Dali::Toolkit::Control *)jarg1; + { + try { + (arg1)->ClearKeyInputFocus(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) { + void * jresult ; + Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; + Dali::PinchGestureDetector result; + + arg1 = (Dali::Toolkit::Control *)jarg1; + { + try { + result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) { + void * jresult ; + Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; + Dali::PanGestureDetector result; + + arg1 = (Dali::Toolkit::Control *)jarg1; + { + try { + result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) { + void * jresult ; + Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; + Dali::TapGestureDetector result; + + arg1 = (Dali::Toolkit::Control *)jarg1; + { + try { + result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) { + void * jresult ; + Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; + Dali::LongPressGestureDetector result; + + arg1 = (Dali::Toolkit::Control *)jarg1; + { + try { + result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) { + Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Control *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + (arg1)->SetStyleName((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + + + //argout typemap for const std::string& + +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) { + char * jresult ; + Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; + std::string *result = 0 ; + + arg1 = (Dali::Toolkit::Control *)jarg1; + { + try { + result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) { + Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; + Dali::Vector4 *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Control *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) { + Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; + + arg1 = (Dali::Toolkit::Control *)jarg1; + { + try { + (arg1)->ClearBackground(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::Control *arg1 = 0 ; + Dali::Toolkit::Control *result = 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2) +{ + int jresult; + Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; + arg1 = (Dali::Toolkit::Control *)jarg1; + + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0); + return 0; + } + + Dali::Property::Index arg2 = 0 ; + arg2 = (Dali::Property::Index)jarg2; + + Toolkit::Visual::ResourceStatus result; + { + try { + result = arg1->GetVisualResourceStatus(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2) +{ + void * jresult; + Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; + arg1 = (Dali::Toolkit::Control *)jarg1; + + Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 ); + + Dali::Toolkit::TransitionData *arg2 = 0 ; + Dali::Animation result; + + arg2 = (Dali::Toolkit::TransitionData *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0); + return 0; + } + { + try { + result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Animation((const Dali::Animation &)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 ) +{ + Dali::Toolkit::Control arg1; + Dali::Toolkit::Control *argp1 = (Dali::Toolkit::Control *)jarg1; + + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0); + } + arg1 = *argp1; + + Dali::Property::Index arg2 = 0 ; + arg2 = (Dali::Property::Index)jarg2; + + Dali::Property::Index arg3 = 0 ; + arg3 = (Dali::Property::Index)jarg3; + + Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4; + + { + try { + DevelControl::DoAction(arg1, arg2, arg3, *arg4); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_View_GetVisualProperty(void* control, int propertyIndex, int visualPropertyIndex) +{ + if (!control) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Given control is null", 0); + return 0; + } + + void* result = 0; + try + { + Dali::Property property = DevelControl::GetVisualProperty(*((Dali::Toolkit::Control*)control), (Dali::Property::Index)propertyIndex, (Dali::Property::Index)visualPropertyIndex); + result = new Dali::Property(property.object, property.propertyIndex, property.componentIndex); + } + CALL_CATCH_EXCEPTION(0); + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) { + bool jresult ; + Dali::Toolkit::Control *arg1 = 0 ; + bool result; + + arg1 = (Dali::Toolkit::Control *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0); + return 0; + } + { + try { + result = (bool)arg1->IsResourceReady(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() { + void * jresult ; + Dali::Toolkit::KeyInputFocusManager *result = 0 ; + + { + try { + result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager(); + } CALL_CATCH_EXCEPTION(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; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() { + void * jresult ; + Dali::Toolkit::KeyInputFocusManager result; + + { + try { + result = Dali::Toolkit::KeyInputFocusManager::Get(); + } CALL_CATCH_EXCEPTION(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); + } CALL_CATCH_EXCEPTION(); + } + +} + + +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(); + } CALL_CATCH_EXCEPTION(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); + } CALL_CATCH_EXCEPTION(); + } + +} + + +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(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() { + void * jresult ; + Dali::Toolkit::Alignment::Padding *result = 0 ; + + { + try { + result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) { + void * jresult ; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + Dali::Toolkit::Alignment::Padding *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + { + try { + result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) { + Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->left = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) { + float jresult ; + Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ; + float result; + + arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1; + result = (float) ((arg1)->left); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) { + Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->right = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) { + float jresult ; + Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ; + float result; + + arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1; + result = (float) ((arg1)->right); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) { + Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->top = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) { + float jresult ; + Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ; + float result; + + arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1; + result = (float) ((arg1)->top); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) { + Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->bottom = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) { + float jresult ; + Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ; + float result; + + arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1; + result = (float) ((arg1)->bottom); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) { + Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ; + + arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() { + void * jresult ; + Dali::Toolkit::Alignment *result = 0 ; + + { + try { + result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) { + void * jresult ; + Dali::Toolkit::Alignment::Type arg1 ; + Dali::Toolkit::Alignment::Type arg2 ; + Dali::Toolkit::Alignment result; + + arg1 = (Dali::Toolkit::Alignment::Type)jarg1; + arg2 = (Dali::Toolkit::Alignment::Type)jarg2; + { + try { + result = Dali::Toolkit::Alignment::New(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) { + void * jresult ; + Dali::Toolkit::Alignment::Type arg1 ; + Dali::Toolkit::Alignment result; + + arg1 = (Dali::Toolkit::Alignment::Type)jarg1; + { + try { + result = Dali::Toolkit::Alignment::New(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() { + void * jresult ; + Dali::Toolkit::Alignment result; + + { + try { + result = Dali::Toolkit::Alignment::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::Alignment *arg1 = 0 ; + Dali::Toolkit::Alignment *result = 0 ; + + arg1 = (Dali::Toolkit::Alignment *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) { + Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ; + + arg1 = (Dali::Toolkit::Alignment *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::Alignment 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::Alignment::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) { + Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ; + Dali::Toolkit::Alignment::Type arg2 ; + + arg1 = (Dali::Toolkit::Alignment *)jarg1; + arg2 = (Dali::Toolkit::Alignment::Type)jarg2; + { + try { + (arg1)->SetAlignmentType(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) { + int jresult ; + Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ; + Dali::Toolkit::Alignment::Type result; + + arg1 = (Dali::Toolkit::Alignment *)jarg1; + { + try { + result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) { + Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ; + Dali::Toolkit::Alignment::Scaling arg2 ; + + arg1 = (Dali::Toolkit::Alignment *)jarg1; + arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2; + { + try { + (arg1)->SetScaling(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) { + int jresult ; + Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ; + Dali::Toolkit::Alignment::Scaling result; + + arg1 = (Dali::Toolkit::Alignment *)jarg1; + { + try { + result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) { + Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ; + Dali::Toolkit::Alignment::Padding *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Alignment *)jarg1; + arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0); + return ; + } + { + try { + (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) { + void * jresult ; + Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ; + Dali::Toolkit::Alignment::Padding *result = 0 ; + + arg1 = (Dali::Toolkit::Alignment *)jarg1; + { + try { + result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ; + Dali::Toolkit::Alignment *arg2 = 0 ; + Dali::Toolkit::Alignment *result = 0 ; + + arg1 = (Dali::Toolkit::Alignment *)jarg1; + arg2 = (Dali::Toolkit::Alignment *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +// Signals + +#ifndef GENERATE_CONTROL_SIGNAL +#define GENERATE_CONTROL_SIGNAL(HType, SignalName) GENERATE_SIGNAL(Dali::Toolkit::Control*, HType, Dali_View, SignalName) +#endif + + +GENERATE_CONTROL_SIGNAL(bool(*)(Dali::Toolkit::Control, Dali::KeyEvent const&), KeyEventSignal) +// CSharp_Dali_View_KeyEventSignal_Connect +// CSharp_Dali_View_KeyEventSignal_Disconnect + +GENERATE_CONTROL_SIGNAL(void(*)(Dali::Toolkit::Control), KeyInputFocusGainedSignal) +// CSharp_Dali_View_KeyInputFocusGainedSignal_Connect +// CSharp_Dali_View_KeyInputFocusGainedSignal_Disconnect + +GENERATE_CONTROL_SIGNAL(void(*)(Dali::Toolkit::Control), KeyInputFocusLostSignal) +// CSharp_Dali_View_KeyInputFocusLostSignal_Connect +// CSharp_Dali_View_KeyInputFocusLostSignal_Disconnect + +GENERATE_CONTROL_SIGNAL(void(*)(Dali::Toolkit::Control), ResourceReadySignal) +// CSharp_Dali_View_ResourceReadySignal_Connect +// CSharp_Dali_View_ResourceReadySignal_Disconnect + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::Control *arg1 = 0 ; + Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ; + + arg1 = (Dali::Toolkit::Control *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Toolkit::Control::KeyEventSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; + Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::Internal::Control *)jarg1; + { + try { + result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() { + void * jresult ; + Dali::Toolkit::FlexContainer *result = 0 ; + + { + try { + result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::FlexContainer *arg1 = 0 ; + Dali::Toolkit::FlexContainer *result = 0 ; + + arg1 = (Dali::Toolkit::FlexContainer *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ; + Dali::Toolkit::FlexContainer *arg2 = 0 ; + Dali::Toolkit::FlexContainer *result = 0 ; + + arg1 = (Dali::Toolkit::FlexContainer *)jarg1; + arg2 = (Dali::Toolkit::FlexContainer *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) { + Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ; + + arg1 = (Dali::Toolkit::FlexContainer *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() { + void * jresult ; + Dali::Toolkit::FlexContainer result; + + { + try { + result = Dali::Toolkit::FlexContainer::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::FlexContainer 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::FlexContainer::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() { + void * jresult ; + Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ; + + { + try { + result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) { + Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ; + + arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() { + void * jresult ; + Dali::Toolkit::ImageView::Property *result = 0 ; + + { + try { + result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) { + Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ; + + arg1 = (Dali::Toolkit::ImageView::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() { + void * jresult ; + Dali::Toolkit::ImageView *result = 0 ; + + { + try { + result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() { + void * jresult ; + Dali::Toolkit::ImageView result; + + { + try { + result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::Toolkit::ImageView result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + { + try { + result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::ImageDimensions arg2 ; + Dali::ImageDimensions *argp2 ; + Dali::Toolkit::ImageView result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + argp2 = (Dali::ImageDimensions *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) { + Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ; + + arg1 = (Dali::Toolkit::ImageView *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::ImageView *arg1 = 0 ; + Dali::Toolkit::ImageView *result = 0 ; + + arg1 = (Dali::Toolkit::ImageView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ; + Dali::Toolkit::ImageView *arg2 = 0 ; + Dali::Toolkit::ImageView *result = 0 ; + + arg1 = (Dali::Toolkit::ImageView *)jarg1; + arg2 = (Dali::Toolkit::ImageView *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::ImageView 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::ImageView::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) { + Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::Toolkit::ImageView *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + (arg1)->SetImage((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) { + Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ; + std::string *arg2 = 0 ; + Dali::ImageDimensions arg3 ; + Dali::ImageDimensions *argp3 ; + + arg1 = (Dali::Toolkit::ImageView *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + argp3 = (Dali::ImageDimensions *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return ; + } + arg3 = *argp3; + { + try { + (arg1)->SetImage((std::string const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() { + void * jresult ; + Dali::Toolkit::ScrollBar::Property *result = 0 ; + + { + try { + result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) { + Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ; + + arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() { + void * jresult ; + Dali::Toolkit::ScrollBar *result = 0 ; + + { + try { + result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::ScrollBar *arg1 = 0 ; + Dali::Toolkit::ScrollBar *result = 0 ; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + Dali::Toolkit::ScrollBar *arg2 = 0 ; + Dali::Toolkit::ScrollBar *result = 0 ; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + arg2 = (Dali::Toolkit::ScrollBar *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) { + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) { + void * jresult ; + Dali::Toolkit::ScrollBar::Direction arg1 ; + Dali::Toolkit::ScrollBar result; + + arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1; + { + try { + result = Dali::Toolkit::ScrollBar::New(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() { + void * jresult ; + Dali::Toolkit::ScrollBar result; + + { + try { + result = Dali::Toolkit::ScrollBar::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::ScrollBar 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::ScrollBar::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) { + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + Dali::Handle arg2 ; + Dali::Property::Index arg3 ; + Dali::Property::Index arg4 ; + Dali::Property::Index arg5 ; + Dali::Property::Index arg6 ; + Dali::Handle *argp2 ; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + argp2 = (Dali::Handle *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::Property::Index)jarg3; + arg4 = (Dali::Property::Index)jarg4; + arg5 = (Dali::Property::Index)jarg5; + arg6 = (Dali::Property::Index)jarg6; + { + try { + (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetScrollIndicator(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) { + void * jresult ; + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + Dali::Actor result; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + { + try { + result = (arg1)->GetScrollIndicator(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0); + return ; + } + { + try { + (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) { + void * jresult ; + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + { + try { + jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)(((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals())); + } CALL_CATCH_EXCEPTION(0); + } + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) { + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + Dali::Toolkit::ScrollBar::Direction arg2 ; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2; + { + try { + (arg1)->SetScrollDirection(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) { + int jresult ; + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + Dali::Toolkit::ScrollBar::Direction result; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + { + try { + result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) { + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2; + { + try { + (arg1)->SetIndicatorHeightPolicy(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) { + int jresult ; + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + { + try { + result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) { + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetIndicatorFixedHeight(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) { + float jresult ; + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + { + try { + result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) { + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetIndicatorShowDuration(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) { + float jresult ; + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + { + try { + result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) { + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetIndicatorHideDuration(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) { + float jresult ; + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + { + try { + result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) { + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + { + try { + (arg1)->ShowIndicator(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) { + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + { + try { + (arg1)->HideIndicator(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + { + try { + result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; + Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::ScrollBar *)jarg1; + { + try { + result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() { + void * jresult ; + Dali::Toolkit::Scrollable::Property *result = 0 ; + + { + try { + result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) { + Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ; + + arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() { + void * jresult ; + Dali::Toolkit::Scrollable *result = 0 ; + + { + try { + result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::Scrollable *arg1 = 0 ; + Dali::Toolkit::Scrollable *result = 0 ; + + arg1 = (Dali::Toolkit::Scrollable *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; + Dali::Toolkit::Scrollable *arg2 = 0 ; + Dali::Toolkit::Scrollable *result = 0 ; + + arg1 = (Dali::Toolkit::Scrollable *)jarg1; + arg2 = (Dali::Toolkit::Scrollable *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) { + Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; + + arg1 = (Dali::Toolkit::Scrollable *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::Scrollable 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::Scrollable::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result); + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) { + bool jresult ; + Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::Scrollable *)jarg1; + { + try { + result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, bool jarg2) { + Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; + bool arg2 ; + + arg1 = (Dali::Toolkit::Scrollable *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->SetOvershootEnabled(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) { + Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; + Dali::Vector4 *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Scrollable *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) { + void * jresult ; + Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; + Dali::Vector4 result; + + arg1 = (Dali::Toolkit::Scrollable *)jarg1; + { + try { + result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) { + Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::Scrollable *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetOvershootAnimationSpeed(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) { + float jresult ; + Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; + float result; + + arg1 = (Dali::Toolkit::Scrollable *)jarg1; + { + try { + result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; + Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::Scrollable *)jarg1; + { + try { + result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; + Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::Scrollable *)jarg1; + { + try { + result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; + Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::Scrollable *)jarg1; + { + try { + result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) { + bool jresult ; + Dali::Toolkit::ControlOrientation::Type arg1 ; + bool result; + + arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1; + { + try { + result = (bool)Dali::Toolkit::IsVertical(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) { + bool jresult ; + Dali::Toolkit::ControlOrientation::Type arg1 ; + bool result; + + arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1; + { + try { + result = (bool)Dali::Toolkit::IsHorizontal(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) { + void * jresult ; + unsigned int arg1 ; + unsigned int arg2 ; + Dali::Toolkit::ItemRange *result = 0 ; + + arg1 = (unsigned int)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::ItemRange *arg1 = 0 ; + Dali::Toolkit::ItemRange *result = 0 ; + + arg1 = (Dali::Toolkit::ItemRange *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ; + Dali::Toolkit::ItemRange *arg2 = 0 ; + Dali::Toolkit::ItemRange *result = 0 ; + + arg1 = (Dali::Toolkit::ItemRange *)jarg1; + arg2 = (Dali::Toolkit::ItemRange *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) { + bool jresult ; + Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ; + unsigned int arg2 ; + bool result; + + arg1 = (Dali::Toolkit::ItemRange *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = (bool)(arg1)->Within(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ; + Dali::Toolkit::ItemRange *arg2 = 0 ; + SwigValueWrapper< Dali::Toolkit::ItemRange > result; + + arg1 = (Dali::Toolkit::ItemRange *)jarg1; + arg2 = (Dali::Toolkit::ItemRange *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0); + return 0; + } + { + try { + result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Toolkit::ItemRange *)jarg1; + arg2 = (unsigned int)jarg2; + if (arg1) (arg1)->begin = arg2; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::ItemRange *)jarg1; + result = (unsigned int) ((arg1)->begin); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Toolkit::ItemRange *)jarg1; + arg2 = (unsigned int)jarg2; + if (arg1) (arg1)->end = arg2; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::ItemRange *)jarg1; + result = (unsigned int) ((arg1)->end); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) { + Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ; + + arg1 = (Dali::Toolkit::ItemRange *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) { + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) { + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + Dali::Toolkit::ControlOrientation::Type arg2 ; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2; + { + try { + (arg1)->SetOrientation(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) { + int jresult ; + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + Dali::Toolkit::ControlOrientation::Type result; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + { + try { + result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) { + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + Dali::Property::Map *arg2 = 0 ; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + arg2 = (Dali::Property::Map *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); + return ; + } + { + try { + (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) { + void * jresult ; + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + Dali::Property::Map result; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + { + try { + result = (arg1)->GetLayoutProperties(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Property::Map((const Dali::Property::Map &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) { + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + unsigned int arg2 ; + Dali::Vector3 *arg3 = 0 ; + Dali::Vector3 *arg4 = 0 ; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (Dali::Vector3 *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + arg4 = (Dali::Vector3 *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); + return ; + } + { + try { + ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) { + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + Dali::Vector3 *arg2 = 0 ; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetItemSize((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) { + float jresult ; + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + unsigned int arg2 ; + Dali::Vector3 arg3 ; + Dali::Vector3 *argp3 ; + float result; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + arg2 = (unsigned int)jarg2; + argp3 = (Dali::Vector3 *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0); + return 0; + } + arg3 = *argp3; + { + try { + result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) { + float jresult ; + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + float arg2 ; + float result; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) { + float jresult ; + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + unsigned int arg2 ; + float result; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) { + void * jresult ; + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + float arg2 ; + Dali::Vector3 arg3 ; + Dali::Vector3 *argp3 ; + SwigValueWrapper< Dali::Toolkit::ItemRange > result; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + arg2 = (float)jarg2; + argp3 = (Dali::Vector3 *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0); + return 0; + } + arg3 = *argp3; + { + try { + result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result); + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) { + float jresult ; + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + int arg2 ; + float arg3 ; + Dali::Vector3 *arg4 = 0 ; + float result; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + arg2 = (int)jarg2; + arg3 = (float)jarg3; + arg4 = (Dali::Vector3 *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + Dali::Vector3 arg2 ; + Dali::Vector3 *argp2 ; + unsigned int result; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + argp2 = (Dali::Vector3 *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) { + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + unsigned int arg2 ; + Dali::Vector3 *arg3 = 0 ; + Dali::Vector3 *arg4 = 0 ; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (Dali::Vector3 *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + arg4 = (Dali::Vector3 *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); + return ; + } + { + try { + ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) { + void * jresult ; + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + Dali::Degree result; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + { + try { + result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Degree((const Dali::Degree &)result); + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) { + float jresult ; + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + { + try { + result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) { + float jresult ; + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + { + try { + result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) { + float jresult ; + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + { + try { + result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, bool jarg5) { + int jresult ; + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + int arg2 ; + int arg3 ; + Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ; + bool arg5 ; + int result; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4; + arg5 = jarg5 ? true : false; + { + try { + result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) { + float jresult ; + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + { + try { + result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) { + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + Dali::Actor *arg2 = 0 ; + int arg3 ; + Dali::Vector3 *arg4 = 0 ; + Dali::Actor *arg5 = 0 ; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + arg2 = (Dali::Actor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); + return ; + } + arg3 = (int)jarg3; + arg4 = (Dali::Vector3 *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + arg5 = (Dali::Actor *)jarg5; + if (!arg5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); + return ; + } + { + try { + (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) { + void * jresult ; + Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; + int arg2 ; + float arg3 ; + Dali::Vector3 *arg4 = 0 ; + Dali::Vector3 result; + + arg1 = (Dali::Toolkit::ItemLayout *)jarg1; + arg2 = (int)jarg2; + arg3 = (float)jarg3; + arg4 = (Dali::Vector3 *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + { + try { + result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) { + void * jresult ; + Dali::Toolkit::DefaultItemLayout::Type arg1 ; + SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result; + + arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1; + { + try { + result = Dali::Toolkit::DefaultItemLayout::New(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) { + Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ; + + arg1 = (Dali::Toolkit::ItemFactory *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::ItemFactory *)jarg1; + { + try { + result = (unsigned int)(arg1)->GetNumberOfItems(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) { + void * jresult ; + Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ; + unsigned int arg2 ; + Dali::Actor result; + + arg1 = (Dali::Toolkit::ItemFactory *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = (arg1)->NewItem(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) { + Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ; + unsigned int arg2 ; + Dali::Actor arg3 ; + Dali::Actor *argp3 ; + + arg1 = (Dali::Toolkit::ItemFactory *)jarg1; + arg2 = (unsigned int)jarg2; + argp3 = (Dali::Actor *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg3 = *argp3; + { + try { + (arg1)->ItemReleased(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) { + Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ; + unsigned int arg2 ; + Dali::Actor arg3 ; + Dali::Actor *argp3 ; + + arg1 = (Dali::Toolkit::ItemFactory *)jarg1; + arg2 = (unsigned int)jarg2; + argp3 = (Dali::Actor *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg3 = *argp3; + { + try { + (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() { + void * jresult ; + Dali::Toolkit::ItemView::Property *result = 0 ; + + { + try { + result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) { + Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ; + + arg1 = (Dali::Toolkit::ItemView::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() { + void * jresult ; + Dali::Toolkit::ItemView *result = 0 ; + + { + try { + result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::ItemView *arg1 = 0 ; + Dali::Toolkit::ItemView *result = 0 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + Dali::Toolkit::ItemView *arg2 = 0 ; + Dali::Toolkit::ItemView *result = 0 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (Dali::Toolkit::ItemView *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) { + void * jresult ; + Dali::Toolkit::ItemFactory *arg1 = 0 ; + Dali::Toolkit::ItemView result; + + arg1 = (Dali::Toolkit::ItemFactory *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0); + return 0; + } + { + try { + result = Dali::Toolkit::ItemView::New(*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::ItemView 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::ItemView::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + { + try { + result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + Dali::Toolkit::ItemLayout *arg2 = 0 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (Dali::Toolkit::ItemLayout *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0); + return ; + } + { + try { + (arg1)->AddLayout(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + (arg1)->RemoveLayout(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) { + void * jresult ; + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + unsigned int arg2 ; + SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) { + void * jresult ; + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + { + try { + result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result); + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) { + float jresult ; + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + Dali::Toolkit::ItemId arg2 ; + float result; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (Dali::Toolkit::ItemId)jarg2; + { + try { + result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + unsigned int arg2 ; + Dali::Vector3 arg3 ; + float arg4 ; + Dali::Vector3 *argp3 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (unsigned int)jarg2; + argp3 = (Dali::Vector3 *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0); + return ; + } + arg3 = *argp3; + arg4 = (float)jarg4; + { + try { + (arg1)->ActivateLayout(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + { + try { + (arg1)->DeactivateCurrentLayout(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetMinimumSwipeSpeed(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) { + float jresult ; + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + { + try { + result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetMinimumSwipeDistance(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) { + float jresult ; + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + { + try { + result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetWheelScrollDistanceStep(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) { + float jresult ; + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + { + try { + result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, bool jarg2) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + bool arg2 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->SetAnchoring(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) { + bool jresult ; + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + { + try { + result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetAnchoringDuration(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) { + float jresult ; + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + { + try { + result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + Dali::Toolkit::ItemId arg2 ; + float arg3 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (Dali::Toolkit::ItemId)jarg2; + arg3 = (float)jarg3; + { + try { + (arg1)->ScrollToItem(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetRefreshInterval(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) { + float jresult ; + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + { + try { + result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + { + try { + (arg1)->Refresh(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) { + void * jresult ; + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + Dali::Toolkit::ItemId arg2 ; + Dali::Actor result; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (Dali::Toolkit::ItemId)jarg2; + { + try { + result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + Dali::Toolkit::ItemId result; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + Dali::Toolkit::Item arg2 ; + float arg3 ; + Dali::Toolkit::Item *argp2 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + argp2 = (Dali::Toolkit::Item *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0); + return ; + } + arg2 = *argp2; + arg3 = (float)jarg3; + { + try { + (arg1)->InsertItem(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + Dali::Toolkit::ItemContainer *arg2 = 0 ; + float arg3 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (Dali::Toolkit::ItemContainer *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0); + return ; + } + arg3 = (float)jarg3; + { + try { + (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + Dali::Toolkit::ItemId arg2 ; + float arg3 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (Dali::Toolkit::ItemId)jarg2; + arg3 = (float)jarg3; + { + try { + (arg1)->RemoveItem(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + Dali::Toolkit::ItemIdContainer *arg2 = 0 ; + float arg3 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0); + return ; + } + arg3 = (float)jarg3; + { + try { + (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + Dali::Toolkit::Item arg2 ; + float arg3 ; + Dali::Toolkit::Item *argp2 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + argp2 = (Dali::Toolkit::Item *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0); + return ; + } + arg2 = *argp2; + arg3 = (float)jarg3; + { + try { + (arg1)->ReplaceItem(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + Dali::Toolkit::ItemContainer *arg2 = 0 ; + float arg3 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (Dali::Toolkit::ItemContainer *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0); + return ; + } + arg3 = (float)jarg3; + { + try { + (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + Dali::Vector3 *arg2 = 0 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) { + void * jresult ; + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + Dali::Vector3 result; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + { + try { + result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + Dali::Vector3 *arg2 = 0 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) { + void * jresult ; + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + Dali::Vector3 result; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + { + try { + result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector3((const Dali::Vector3 &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) { + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + Dali::Toolkit::ItemRange *arg2 = 0 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + arg2 = (Dali::Toolkit::ItemRange *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0); + return ; + } + { + try { + (arg1)->GetItemsRange(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; + Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::ItemView *)jarg1; + { + try { + result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) { + Dali::Vector3 *arg1 = 0 ; + PropertyInputContainer *arg2 = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); + return ; + } + arg2 = (PropertyInputContainer *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0); + return ; + } + { + try { + Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) { + Dali::Vector3 *arg1 = 0 ; + PropertyInputContainer *arg2 = 0 ; + + arg1 = (Dali::Vector3 *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); + return ; + } + arg2 = (PropertyInputContainer *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0); + return ; + } + { + try { + Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() { + void * jresult ; + Dali::Toolkit::ScrollViewEffect *result = 0 ; + + { + try { + result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) { + Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ; + + arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) { + void * jresult ; + Dali::Path arg1 ; + Dali::Vector3 *arg2 = 0 ; + Dali::Property::Index arg3 ; + Dali::Vector3 *arg4 = 0 ; + unsigned int arg5 ; + Dali::Path *argp1 ; + Dali::Toolkit::ScrollViewPagePathEffect result; + + argp1 = (Dali::Path *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0); + return 0; + } + arg1 = *argp1; + arg2 = (Dali::Vector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + arg3 = (Dali::Property::Index)jarg3; + arg4 = (Dali::Vector3 *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); + return 0; + } + arg5 = (unsigned int)jarg5; + { + try { + result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() { + void * jresult ; + Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ; + + { + try { + result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::ScrollViewPagePathEffect 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::ScrollViewPagePathEffect::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) { + Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ; + Dali::Actor arg2 ; + unsigned int arg3 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + arg3 = (unsigned int)jarg3; + { + try { + (arg1)->ApplyToPage(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) { + Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ; + + arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) { + Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ; + Dali::Toolkit::ClampState arg2 ; + + arg1 = (Dali::Toolkit::ClampState2D *)jarg1; + arg2 = (Dali::Toolkit::ClampState)jarg2; + if (arg1) (arg1)->x = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) { + int jresult ; + Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ; + Dali::Toolkit::ClampState result; + + arg1 = (Dali::Toolkit::ClampState2D *)jarg1; + result = (Dali::Toolkit::ClampState) ((arg1)->x); + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) { + Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ; + Dali::Toolkit::ClampState arg2 ; + + arg1 = (Dali::Toolkit::ClampState2D *)jarg1; + arg2 = (Dali::Toolkit::ClampState)jarg2; + if (arg1) (arg1)->y = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) { + int jresult ; + Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ; + Dali::Toolkit::ClampState result; + + arg1 = (Dali::Toolkit::ClampState2D *)jarg1; + result = (Dali::Toolkit::ClampState) ((arg1)->y); + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() { + void * jresult ; + Dali::Toolkit::ClampState2D *result = 0 ; + + { + try { + result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) { + Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ; + + arg1 = (Dali::Toolkit::ClampState2D *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, bool jarg3) { + void * jresult ; + float arg1 ; + float arg2 ; + bool arg3 ; + Dali::Toolkit::RulerDomain *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + arg3 = jarg3 ? true : false; + { + try { + result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) { + void * jresult ; + float arg1 ; + float arg2 ; + Dali::Toolkit::RulerDomain *result = 0 ; + + arg1 = (float)jarg1; + arg2 = (float)jarg2; + { + try { + result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) { + Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::RulerDomain *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->min = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) { + float jresult ; + Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; + float result; + + arg1 = (Dali::Toolkit::RulerDomain *)jarg1; + result = (float) ((arg1)->min); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) { + Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::RulerDomain *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->max = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) { + float jresult ; + Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; + float result; + + arg1 = (Dali::Toolkit::RulerDomain *)jarg1; + result = (float) ((arg1)->max); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, bool jarg2) { + Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; + bool arg2 ; + + arg1 = (Dali::Toolkit::RulerDomain *)jarg1; + arg2 = jarg2 ? true : false; + if (arg1) (arg1)->enabled = arg2; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) { + bool jresult ; + Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::RulerDomain *)jarg1; + result = (bool) ((arg1)->enabled); + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) { + float jresult ; + Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; + float arg2 ; + float arg3 ; + float arg4 ; + float result; + + arg1 = (Dali::Toolkit::RulerDomain *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + { + try { + result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) { + float jresult ; + Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; + float arg2 ; + float arg3 ; + float result; + + arg1 = (Dali::Toolkit::RulerDomain *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + { + try { + result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) { + float jresult ; + Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; + float arg2 ; + float result; + + arg1 = (Dali::Toolkit::RulerDomain *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) { + float jresult ; + Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; + float arg2 ; + float arg3 ; + float arg4 ; + Dali::Toolkit::ClampState *arg5 = 0 ; + float result; + + arg1 = (Dali::Toolkit::RulerDomain *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + arg5 = (Dali::Toolkit::ClampState *)jarg5; + if (!arg5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0); + return 0; + } + { + try { + result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) { + float jresult ; + Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; + float result; + + arg1 = (Dali::Toolkit::RulerDomain *)jarg1; + { + try { + result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) { + Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; + + arg1 = (Dali::Toolkit::RulerDomain *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) { + float jresult ; + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + float arg2 ; + float arg3 ; + float result; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + { + try { + result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) { + float jresult ; + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + float arg2 ; + float result; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) { + float jresult ; + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + unsigned int arg2 ; + unsigned int *arg3 = 0 ; + bool arg4 ; + float result; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (unsigned int *)jarg3; + arg4 = jarg4 ? true : false; + { + try { + result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) { + unsigned int jresult ; + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + float arg2 ; + bool arg3 ; + unsigned int result; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + arg2 = (float)jarg2; + arg3 = jarg3 ? true : false; + { + try { + result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + { + try { + result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) { + int jresult ; + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + Dali::Toolkit::Ruler::RulerType result; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + { + try { + result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) { + bool jresult ; + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + { + try { + result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) { + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + { + try { + (arg1)->Enable(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) { + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + { + try { + (arg1)->Disable(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) { + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ; + Dali::Toolkit::RulerDomain *argp2 ; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + argp2 = (Dali::Toolkit::RulerDomain *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetDomain(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) { + void * jresult ; + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + Dali::Toolkit::RulerDomain *result = 0 ; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + { + try { + result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) { + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + { + try { + (arg1)->DisableDomain(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) { + float jresult ; + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + float arg2 ; + float arg3 ; + float arg4 ; + float result; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + { + try { + result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) { + float jresult ; + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + float arg2 ; + float arg3 ; + float result; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + { + try { + result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) { + float jresult ; + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + float arg2 ; + float result; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) { + float jresult ; + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + float arg2 ; + float arg3 ; + float arg4 ; + Dali::Toolkit::ClampState *arg5 = 0 ; + float result; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + arg5 = (Dali::Toolkit::ClampState *)jarg5; + if (!arg5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0); + return 0; + } + { + try { + result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) { + float jresult ; + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float result; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + arg5 = (float)jarg5; + { + try { + result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) { + float jresult ; + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + float arg2 ; + float arg3 ; + float arg4 ; + float result; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + { + try { + result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) { + float jresult ; + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + float arg2 ; + float arg3 ; + float result; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + { + try { + result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) { + float jresult ; + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + float arg2 ; + float result; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) { + float jresult ; + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + Dali::Toolkit::ClampState *arg6 = 0 ; + float result; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + arg5 = (float)jarg5; + arg6 = (Dali::Toolkit::ClampState *)jarg6; + if (!arg6) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0); + return 0; + } + { + try { + result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() { + void * jresult ; + Dali::Toolkit::DefaultRuler *result = 0 ; + + { + try { + result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) { + float jresult ; + Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ; + float arg2 ; + float arg3 ; + float result; + + arg1 = (Dali::Toolkit::DefaultRuler *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + { + try { + result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) { + float jresult ; + Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ; + unsigned int arg2 ; + unsigned int *arg3 = 0 ; + bool arg4 ; + float result; + + arg1 = (Dali::Toolkit::DefaultRuler *)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (unsigned int *)jarg3; + arg4 = jarg4 ? true : false; + { + try { + result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) { + unsigned int jresult ; + Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ; + float arg2 ; + bool arg3 ; + unsigned int result; + + arg1 = (Dali::Toolkit::DefaultRuler *)jarg1; + arg2 = (float)jarg2; + arg3 = jarg3 ? true : false; + { + try { + result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::DefaultRuler *)jarg1; + { + try { + result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) { + Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ; + + arg1 = (Dali::Toolkit::DefaultRuler *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) { + void * jresult ; + float arg1 ; + Dali::Toolkit::FixedRuler *result = 0 ; + + arg1 = (float)jarg1; + { + try { + result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() { + void * jresult ; + Dali::Toolkit::FixedRuler *result = 0 ; + + { + try { + result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) { + float jresult ; + Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ; + float arg2 ; + float arg3 ; + float result; + + arg1 = (Dali::Toolkit::FixedRuler *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + { + try { + result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) { + float jresult ; + Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ; + unsigned int arg2 ; + unsigned int *arg3 = 0 ; + bool arg4 ; + float result; + + arg1 = (Dali::Toolkit::FixedRuler *)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (unsigned int *)jarg3; + arg4 = jarg4 ? true : false; + { + try { + result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) { + unsigned int jresult ; + Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ; + float arg2 ; + bool arg3 ; + unsigned int result; + + arg1 = (Dali::Toolkit::FixedRuler *)jarg1; + arg2 = (float)jarg2; + arg3 = jarg3 ? true : false; + { + try { + result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::FixedRuler *)jarg1; + { + try { + result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) { + Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ; + + arg1 = (Dali::Toolkit::FixedRuler *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ; + Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ; + + arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1; + arg2 = (Dali::Toolkit::ClampState2D *)jarg2; + if (arg1) (arg1)->scale = *arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) { + void * jresult ; + Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ; + Dali::Toolkit::ClampState2D *result = 0 ; + + arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1; + result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ; + Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ; + + arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1; + arg2 = (Dali::Toolkit::ClampState2D *)jarg2; + if (arg1) (arg1)->position = *arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) { + void * jresult ; + Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ; + Dali::Toolkit::ClampState2D *result = 0 ; + + arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1; + result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) { + Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ; + Dali::Toolkit::ClampState arg2 ; + + arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1; + arg2 = (Dali::Toolkit::ClampState)jarg2; + if (arg1) (arg1)->rotation = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) { + int jresult ; + Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ; + Dali::Toolkit::ClampState result; + + arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1; + result = (Dali::Toolkit::ClampState) ((arg1)->rotation); + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() { + void * jresult ; + Dali::Toolkit::ScrollView::ClampEvent *result = 0 ; + + { + try { + result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) { + Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ; + + arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) { + Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ; + Dali::Toolkit::SnapType arg2 ; + + arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1; + arg2 = (Dali::Toolkit::SnapType)jarg2; + if (arg1) (arg1)->type = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) { + int jresult ; + Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ; + Dali::Toolkit::SnapType result; + + arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1; + result = (Dali::Toolkit::SnapType) ((arg1)->type); + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ; + Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ; + + arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (arg1) (arg1)->position = *arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) { + void * jresult ; + Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ; + Dali::Vector2 *result = 0 ; + + arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1; + result = (Dali::Vector2 *)& ((arg1)->position); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) { + Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->duration = arg2; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) { + float jresult ; + Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1; + result = (float) ((arg1)->duration); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() { + void * jresult ; + Dali::Toolkit::ScrollView::SnapEvent *result = 0 ; + + { + try { + result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) { + Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ; + + arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() { + void * jresult ; + Dali::Toolkit::ScrollView::Property *result = 0 ; + + { + try { + result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) { + Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ; + + arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() { + void * jresult ; + Dali::Toolkit::ScrollView *result = 0 ; + + { + try { + result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::ScrollView *arg1 = 0 ; + Dali::Toolkit::ScrollView *result = 0 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Toolkit::ScrollView *arg2 = 0 ; + Dali::Toolkit::ScrollView *result = 0 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (Dali::Toolkit::ScrollView *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() { + void * jresult ; + Dali::Toolkit::ScrollView result; + + { + try { + result = Dali::Toolkit::ScrollView::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::ScrollView 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::ScrollView::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) { + void * jresult ; + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::AlphaFunction result; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::AlphaFunction arg2 ; + Dali::AlphaFunction *argp2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + argp2 = (Dali::AlphaFunction *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetScrollSnapAlphaFunction(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) { + void * jresult ; + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::AlphaFunction result; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::AlphaFunction arg2 ; + Dali::AlphaFunction *argp2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + argp2 = (Dali::AlphaFunction *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetScrollFlickAlphaFunction(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) { + float jresult ; + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetScrollSnapDuration(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) { + float jresult ; + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetScrollFlickDuration(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Toolkit::RulerPtr arg2 ; + Dali::Toolkit::RulerPtr *argp2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + argp2 = (Dali::Toolkit::RulerPtr *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetRulerX(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Toolkit::RulerPtr arg2 ; + Dali::Toolkit::RulerPtr *argp2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + argp2 = (Dali::Toolkit::RulerPtr *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetRulerY(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, bool jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + bool arg2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->SetScrollSensitive(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + float arg2 ; + float arg3 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + { + try { + (arg1)->SetMaxOvershoot(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::AlphaFunction arg2 ; + Dali::AlphaFunction *argp2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + argp2 = (Dali::AlphaFunction *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetSnapOvershootAlphaFunction(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetSnapOvershootDuration(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, bool jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + bool arg2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->SetActorAutoSnap(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, bool jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + bool arg2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->SetWrapMode(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) { + int jresult ; + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + int result; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + int arg2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (int)jarg2; + { + try { + (arg1)->SetScrollUpdateDistance(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) { + bool jresult ; + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, bool jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + bool arg2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->SetAxisAutoLock(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) { + float jresult ; + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetAxisAutoLockGradient(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) { + float jresult ; + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetFrictionCoefficient(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) { + float jresult ; + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetFlickSpeedCoefficient(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) { + void * jresult ; + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Vector2 *arg2 = 0 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) { + float jresult ; + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetMinimumSpeedForFlick(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) { + float jresult ; + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + float result; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (float)jarg2; + { + try { + (arg1)->SetMaxFlickSpeed(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) { + void * jresult ; + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Vector2 arg2 ; + Dali::Vector2 *argp2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + argp2 = (Dali::Vector2 *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetWheelScrollDistanceStep(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) { + void * jresult ; + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Vector2 *arg2 = 0 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + { + try { + (arg1)->ScrollTo((Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Vector2 *arg2 = 0 ; + float arg3 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + arg3 = (float)jarg3; + { + try { + (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Vector2 *arg2 = 0 ; + float arg3 ; + Dali::AlphaFunction arg4 ; + Dali::AlphaFunction *argp4 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + arg3 = (float)jarg3; + argp4 = (Dali::AlphaFunction *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); + return ; + } + arg4 = *argp4; + { + try { + (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Vector2 *arg2 = 0 ; + float arg3 ; + Dali::Toolkit::DirectionBias arg4 ; + Dali::Toolkit::DirectionBias arg5 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + arg3 = (float)jarg3; + arg4 = (Dali::Toolkit::DirectionBias)jarg4; + arg5 = (Dali::Toolkit::DirectionBias)jarg5; + { + try { + (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Vector2 *arg2 = 0 ; + float arg3 ; + Dali::AlphaFunction arg4 ; + Dali::Toolkit::DirectionBias arg5 ; + Dali::Toolkit::DirectionBias arg6 ; + Dali::AlphaFunction *argp4 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + arg3 = (float)jarg3; + argp4 = (Dali::AlphaFunction *)jarg4; + if (!argp4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); + return ; + } + arg4 = *argp4; + arg5 = (Dali::Toolkit::DirectionBias)jarg5; + arg6 = (Dali::Toolkit::DirectionBias)jarg6; + { + try { + (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + (arg1)->ScrollTo(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + unsigned int arg2 ; + float arg3 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (float)jarg3; + { + try { + (arg1)->ScrollTo(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + unsigned int arg2 ; + float arg3 ; + Dali::Toolkit::DirectionBias arg4 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (float)jarg3; + arg4 = (Dali::Toolkit::DirectionBias)jarg4; + { + try { + (arg1)->ScrollTo(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Actor *arg2 = 0 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (Dali::Actor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); + return ; + } + { + try { + (arg1)->ScrollTo(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Actor *arg2 = 0 ; + float arg3 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + arg2 = (Dali::Actor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); + return ; + } + arg3 = (float)jarg3; + { + try { + (arg1)->ScrollTo(*arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) { + bool jresult ; + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + result = (bool)(arg1)->ScrollToSnapPoint(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Constraint arg2 ; + Dali::Constraint *argp2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + argp2 = (Dali::Constraint *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->ApplyConstraintToChildren(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + (arg1)->RemoveConstraintsFromChildren(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Toolkit::ScrollViewEffect arg2 ; + Dali::Toolkit::ScrollViewEffect *argp2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->ApplyEffect(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Toolkit::ScrollViewEffect arg2 ; + Dali::Toolkit::ScrollViewEffect *argp2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->RemoveEffect(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + (arg1)->RemoveAllEffects(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->BindActor(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->UnbindActor(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Radian arg2 ; + Dali::Radian arg3 ; + Dali::Radian *argp2 ; + Dali::Radian *argp3 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + argp2 = (Dali::Radian *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::Radian *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return ; + } + arg3 = *argp3; + { + try { + (arg1)->SetScrollingDirection(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Radian arg2 ; + Dali::Radian *argp2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + argp2 = (Dali::Radian *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetScrollingDirection(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) { + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Radian arg2 ; + Dali::Radian *argp2 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + argp2 = (Dali::Radian *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->RemoveScrollingDirection(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; + Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::ScrollView *)jarg1; + { + try { + result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() { + void * jresult ; + Dali::Toolkit::TableView::Property *result = 0 ; + + { + try { + result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) { + Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ; + + arg1 = (Dali::Toolkit::TableView::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() { + void * jresult ; + Dali::Toolkit::TableView::ChildProperty *result = 0 ; + + { + try { + result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) { + Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ; + + arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) { + void * jresult ; + unsigned int arg1 ; + unsigned int arg2 ; + unsigned int arg3 ; + unsigned int arg4 ; + Dali::Toolkit::TableView::CellPosition *result = 0 ; + + arg1 = (unsigned int)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (unsigned int)jarg3; + arg4 = (unsigned int)jarg4; + { + try { + result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) { + void * jresult ; + unsigned int arg1 ; + unsigned int arg2 ; + unsigned int arg3 ; + Dali::Toolkit::TableView::CellPosition *result = 0 ; + + arg1 = (unsigned int)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (unsigned int)jarg3; + { + try { + result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) { + void * jresult ; + unsigned int arg1 ; + unsigned int arg2 ; + Dali::Toolkit::TableView::CellPosition *result = 0 ; + + arg1 = (unsigned int)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) { + void * jresult ; + unsigned int arg1 ; + Dali::Toolkit::TableView::CellPosition *result = 0 ; + + arg1 = (unsigned int)jarg1; + { + try { + result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() { + void * jresult ; + Dali::Toolkit::TableView::CellPosition *result = 0 ; + + { + try { + result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1; + arg2 = (unsigned int)jarg2; + if (arg1) (arg1)->rowIndex = arg2; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1; + result = (unsigned int) ((arg1)->rowIndex); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1; + arg2 = (unsigned int)jarg2; + if (arg1) (arg1)->columnIndex = arg2; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1; + result = (unsigned int) ((arg1)->columnIndex); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1; + arg2 = (unsigned int)jarg2; + if (arg1) (arg1)->rowSpan = arg2; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1; + result = (unsigned int) ((arg1)->rowSpan); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1; + arg2 = (unsigned int)jarg2; + if (arg1) (arg1)->columnSpan = arg2; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1; + result = (unsigned int) ((arg1)->columnSpan); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) { + Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ; + + arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() { + void * jresult ; + Dali::Toolkit::TableView *result = 0 ; + + { + try { + result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::TableView *arg1 = 0 ; + Dali::Toolkit::TableView *result = 0 ; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + Dali::Toolkit::TableView *arg2 = 0 ; + Dali::Toolkit::TableView *result = 0 ; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (Dali::Toolkit::TableView *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) { + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) { + void * jresult ; + unsigned int arg1 ; + unsigned int arg2 ; + Dali::Toolkit::TableView result; + + arg1 = (unsigned int)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = Dali::Toolkit::TableView::New(arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::TableView 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::TableView::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result); + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) { + bool jresult ; + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + Dali::Actor arg2 ; + Dali::Toolkit::TableView::CellPosition arg3 ; + Dali::Actor *argp2 ; + Dali::Toolkit::TableView::CellPosition *argp3 ; + bool result; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg2 = *argp2; + argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0); + return 0; + } + arg3 = *argp3; + { + try { + result = (bool)(arg1)->AddChild(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + Dali::Toolkit::TableView::CellPosition arg2 ; + Dali::Toolkit::TableView::CellPosition *argp2 ; + Dali::Actor result; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (arg1)->GetChildAt(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + Dali::Toolkit::TableView::CellPosition arg2 ; + Dali::Toolkit::TableView::CellPosition *argp2 ; + Dali::Actor result; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (arg1)->RemoveChildAt(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) { + bool jresult ; + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + Dali::Actor arg2 ; + Dali::Toolkit::TableView::CellPosition *arg3 = 0 ; + Dali::Actor *argp2 ; + bool result; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg2 = *argp2; + arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0); + return 0; + } + { + try { + result = (bool)(arg1)->FindChildPosition(arg2,*arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + (arg1)->InsertRow(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + (arg1)->DeleteRow(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) { + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + std::vector< Dali::Actor > *arg3 = 0 ; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (std::vector< Dali::Actor > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0); + return ; + } + { + try { + (arg1)->DeleteRow(arg2,*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + (arg1)->InsertColumn(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + (arg1)->DeleteColumn(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) { + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + std::vector< Dali::Actor > *arg3 = 0 ; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (std::vector< Dali::Actor > *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0); + return ; + } + { + try { + (arg1)->DeleteColumn(arg2,*arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) { + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + unsigned int arg3 ; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (unsigned int)jarg3; + { + try { + (arg1)->Resize(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) { + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + unsigned int arg3 ; + std::vector< Dali::Actor > *arg4 = 0 ; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (unsigned int)jarg3; + arg4 = (std::vector< Dali::Actor > *)jarg4; + if (!arg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0); + return ; + } + { + try { + (arg1)->Resize(arg2,arg3,*arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) { + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + Dali::Size arg2 ; + Dali::Size *argp2 ; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + argp2 = (Dali::Size *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetCellPadding(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) { + void * jresult ; + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + Dali::Size result; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + { + try { + result = (arg1)->GetCellPadding(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Size((const Dali::Size &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + (arg1)->SetFitHeight(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) { + bool jresult ; + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + bool result; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + (arg1)->SetFitWidth(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) { + bool jresult ; + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + bool result; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) { + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + float arg3 ; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (float)jarg3; + { + try { + (arg1)->SetFixedHeight(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) { + float jresult ; + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + float result; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) { + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + float arg3 ; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (float)jarg3; + { + try { + (arg1)->SetRelativeHeight(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) { + float jresult ; + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + float result; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) { + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + float arg3 ; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (float)jarg3; + { + try { + (arg1)->SetFixedWidth(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) { + float jresult ; + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + float result; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) { + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + float arg3 ; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (float)jarg3; + { + try { + (arg1)->SetRelativeWidth(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) { + float jresult ; + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int arg2 ; + float result; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + { + try { + result = (unsigned int)(arg1)->GetRows(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + { + try { + result = (unsigned int)(arg1)->GetColumns(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) { + Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; + Dali::Toolkit::TableView::CellPosition arg2 ; + Dali::HorizontalAlignment::Type arg3 ; + Dali::VerticalAlignment::Type arg4 ; + Dali::Toolkit::TableView::CellPosition *argp2 ; + + arg1 = (Dali::Toolkit::TableView *)jarg1; + argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::HorizontalAlignment::Type)jarg3; + arg4 = (Dali::VerticalAlignment::Type)jarg4; + { + try { + (arg1)->SetCellAlignment(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() { + void * jresult ; + Dali::Toolkit::TextLabel::Property *result = 0 ; + + { + try { + result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) { + Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ; + + arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() { + void * jresult ; + Dali::Toolkit::TextLabel result; + + { + try { + result = Dali::Toolkit::TextLabel::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * text) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::Toolkit::TextLabel result; + + if (!text) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(text); + arg1 = &arg1_str; + { + try { + result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New_With_Style(bool hasStyle) { + void * jresult ; + Dali::Toolkit::TextLabel result; + + { + try { + if (hasStyle) { + result = Dali::Toolkit::TextLabel::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS); + } else { + result = Dali::Toolkit::TextLabel::New(); + } + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New_With_String_Style(char * text, bool hasStyle) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::Toolkit::TextLabel result; + + if (!text) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(text); + arg1 = &arg1_str; + { + try { + if (hasStyle) { + result = Dali::Toolkit::TextLabel::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1); + } else { + result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1); + } + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() { + void * jresult ; + Dali::Toolkit::TextLabel *result = 0 ; + + { + try { + result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::TextLabel *arg1 = 0 ; + Dali::Toolkit::TextLabel *result = 0 ; + + arg1 = (Dali::Toolkit::TextLabel *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ; + Dali::Toolkit::TextLabel *arg2 = 0 ; + Dali::Toolkit::TextLabel *result = 0 ; + + arg1 = (Dali::Toolkit::TextLabel *)jarg1; + arg2 = (Dali::Toolkit::TextLabel *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) { + Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ; + + arg1 = (Dali::Toolkit::TextLabel *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::TextLabel 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::TextLabel::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() { + void * jresult ; + Dali::Toolkit::AccessibilityManager *result = 0 ; + + { + try { + result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) { + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() { + void * jresult ; + Dali::Toolkit::AccessibilityManager result; + + { + try { + result = Dali::Toolkit::AccessibilityManager::Get(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) { + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Actor arg2 ; + Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ; + std::string *arg4 = 0 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3; + if (!jarg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg4_str(jarg4); + arg4 = &arg4_str; + { + try { + (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4); + } CALL_CATCH_EXCEPTION(); + } + + + //argout typemap for const std::string& + +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) { + char * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Actor arg2 ; + Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ; + Dali::Actor *argp2 ; + std::string result; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg2 = *argp2; + arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3; + { + try { + result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback((&result)->c_str()); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) { + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Actor arg2 ; + unsigned int arg3 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + arg3 = (unsigned int)jarg3; + { + try { + (arg1)->SetFocusOrder(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + unsigned int result; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + unsigned int arg2 ; + Dali::Actor result; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = (arg1)->GetActorByFocusOrder(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + bool result; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)(arg1)->SetCurrentFocusActor(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Actor result; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (arg1)->GetCurrentFocusActor(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Actor result; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (arg1)->GetCurrentFocusGroup(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (unsigned int)(arg1)->GetCurrentFocusOrder(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) { + bool jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (bool)(arg1)->MoveFocusForward(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) { + bool jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (bool)(arg1)->MoveFocusBackward(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) { + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + (arg1)->ClearFocus(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) { + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + (arg1)->Reset(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, bool jarg3) { + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Actor arg2 ; + bool arg3 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + arg3 = jarg3 ? true : false; + { + try { + (arg1)->SetFocusGroup(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + bool result; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, bool jarg2) { + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + bool arg2 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->SetGroupMode(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) { + bool jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, bool jarg2) { + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + bool arg2 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->SetWrapMode(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) { + bool jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) { + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetFocusIndicatorActor(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Actor result; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (arg1)->GetFocusIndicatorActor(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + Dali::Actor result; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (arg1)->GetFocusGroup(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Vector2 result; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +GENERATE_SIGNAL(Dali::Toolkit::AccessibilityManager*, void(*)(Dali::Actor), Dali_AccessibilityManager, FocusedActorActivatedSignal) +// CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal_Connect +// CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal_Disconnect + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; + Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; + { + try { + result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() { + void * jresult ; + Dali::Toolkit::StyleManager *result = 0 ; + + { + try { + result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) { + Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ; + + arg1 = (Dali::Toolkit::StyleManager *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() { + void * jresult ; + Dali::Toolkit::StyleManager result; + + { + try { + result = Dali::Toolkit::StyleManager::Get(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) { + Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::Toolkit::StyleManager *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + (arg1)->ApplyTheme((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) { + Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ; + + arg1 = (Dali::Toolkit::StyleManager *)jarg1; + { + try { + (arg1)->ApplyDefaultTheme(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) { + Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ; + std::string *arg2 = 0 ; + Dali::Property::Value *arg3 = 0 ; + + arg1 = (Dali::Toolkit::StyleManager *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Property::Value *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); + return ; + } + { + try { + (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3); + } CALL_CATCH_EXCEPTION(); + } + + + //argout typemap for const std::string& + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) { + bool jresult ; + Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ; + std::string *arg2 = 0 ; + Dali::Property::Value *arg3 = 0 ; + bool result; + + arg1 = (Dali::Toolkit::StyleManager *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (Dali::Property::Value *)jarg3; + if (!arg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0); + return 0; + } + { + try { + result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) { + Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ; + Dali::Toolkit::Control arg2 ; + std::string *arg3 = 0 ; + std::string *arg4 = 0 ; + Dali::Toolkit::Control *argp2 ; + + arg1 = (Dali::Toolkit::StyleManager *)jarg1; + argp2 = (Dali::Toolkit::Control *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0); + return ; + } + arg2 = *argp2; + if (!jarg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg3_str(jarg3); + arg3 = &arg3_str; + if (!jarg4) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg4_str(jarg4); + arg4 = &arg4_str; + { + try { + (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4); + } CALL_CATCH_EXCEPTION(); + } + + + //argout typemap for const std::string& + + + //argout typemap for const std::string& + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ; + Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::StyleManager *)jarg1; + { + try { + result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() { + void * jresult ; + Dali::Toolkit::VideoView::Property *result = 0 ; + + { + try { + result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) { + Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ; + + arg1 = (Dali::Toolkit::VideoView::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() { + void * jresult ; + Dali::Toolkit::VideoView result; + + { + try { + result = Dali::Toolkit::VideoView::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::Toolkit::VideoView result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + { + try { + result = Dali::Toolkit::VideoView::New((std::string const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) { + void * jresult ; + Dali::Toolkit::VideoView result; + { + try { + result = Dali::Toolkit::VideoView::New(swCodec); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::Toolkit::VideoView result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + { + try { + result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result); + + //argout typemap for const std::string& + + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_4(unsigned int jarg1) { + void * jresult ; + Dali::VideoSyncMode syncMode; + Dali::Toolkit::VideoView result; + + syncMode = static_cast(jarg1); + + { + try { + result = Dali::Toolkit::DevelVideoView::New(syncMode); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result); + + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() { + void * jresult ; + Dali::Toolkit::VideoView *result = 0 ; + + { + try { + result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) { + Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ; + + arg1 = (Dali::Toolkit::VideoView *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::VideoView *arg1 = 0 ; + Dali::Toolkit::VideoView *result = 0 ; + + arg1 = (Dali::Toolkit::VideoView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ; + Dali::Toolkit::VideoView *arg2 = 0 ; + Dali::Toolkit::VideoView *result = 0 ; + + arg1 = (Dali::Toolkit::VideoView *)jarg1; + arg2 = (Dali::Toolkit::VideoView *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::VideoView 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::VideoView::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) { + Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ; + + arg1 = (Dali::Toolkit::VideoView *)jarg1; + { + try { + (arg1)->Play(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) { + Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ; + + arg1 = (Dali::Toolkit::VideoView *)jarg1; + { + try { + (arg1)->Pause(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) { + Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ; + + arg1 = (Dali::Toolkit::VideoView *)jarg1; + { + try { + (arg1)->Stop(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) { + Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ; + int arg2 ; + + arg1 = (Dali::Toolkit::VideoView *)jarg1; + arg2 = (int)jarg2; + { + try { + (arg1)->Forward(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) { + Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ; + int arg2 ; + + arg1 = (Dali::Toolkit::VideoView *)jarg1; + arg2 = (int)jarg2; + { + try { + (arg1)->Backward(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ; + Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::VideoView *)jarg1; + { + try { + result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle(void * jarg1) +{ + Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1; + if( arg1 == nullptr ) + { + DALI_LOG_ERROR("VideoView is nullptr!"); + return nullptr; + } + void * ret = nullptr; + { + try{ + + Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 ); + ret = Dali::AnyCast< void * >( result ); + + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_New__SWIG_0(void * jarg1, int jarg2) { + void * jresult ; + Dali::Toolkit::CameraView result; + + Dali::Any arg1(jarg1); + Dali::Toolkit::CameraView::DisplayType arg2 = static_cast(jarg2); + { + try { + result = Dali::Toolkit::CameraView::New(arg1, arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::CameraView((const Dali::Toolkit::CameraView &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraView__SWIG_0() { + void * jresult ; + Dali::Toolkit::CameraView *result = 0 ; + + { + try { + result = (Dali::Toolkit::CameraView *)new Dali::Toolkit::CameraView(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraView(void * jarg1) { + Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ; + + arg1 = (Dali::Toolkit::CameraView *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraView__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::CameraView *arg1 = 0 ; + Dali::Toolkit::CameraView *result = 0 ; + + arg1 = (Dali::Toolkit::CameraView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CameraView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::CameraView *)new Dali::Toolkit::CameraView((Dali::Toolkit::CameraView const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ; + Dali::Toolkit::CameraView *arg2 = 0 ; + Dali::Toolkit::CameraView *result = 0 ; + + arg1 = (Dali::Toolkit::CameraView *)jarg1; + arg2 = (Dali::Toolkit::CameraView *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CameraView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::CameraView *) &(arg1)->operator =((Dali::Toolkit::CameraView const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::CameraView 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::CameraView::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::CameraView((const Dali::Toolkit::CameraView &)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraView_Update(void * jarg1) { + Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ; + + arg1 = (Dali::Toolkit::CameraView *)jarg1; + { + try { + (arg1)->Update(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_PlayAnimation(void * jarg1, void * jarg2) +{ + Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView*)jarg1; + if(arg1 == nullptr) + { + DALI_LOG_ERROR("VideoView is nullptr!"); + return; + } + Dali::Animation *arg2 = (Dali::Animation*)jarg2; + if(arg2 == nullptr) + { + DALI_LOG_ERROR("Animation is nullptr!"); + return; + } + + { + try{ + + Toolkit::DevelVideoView::PlayAnimation(*arg1, *arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() { + void * jresult ; + Dali::Toolkit::GaussianBlurView *result = 0 ; + + { + try { + result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::GaussianBlurView *arg1 = 0 ; + Dali::Toolkit::GaussianBlurView *result = 0 ; + + arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; + Dali::Toolkit::GaussianBlurView *arg2 = 0 ; + Dali::Toolkit::GaussianBlurView *result = 0 ; + + arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; + arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) { + Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; + + arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::GaussianBlurView 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::GaussianBlurView::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() { + void * jresult ; + Dali::Toolkit::GaussianBlurView result; + + { + try { + result = Dali::Toolkit::GaussianBlurView::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, bool jarg6) { + void * jresult ; + unsigned int arg1 ; + float arg2 ; + Dali::Pixel::Format arg3 ; + float arg4 ; + float arg5 ; + bool arg6 ; + Dali::Toolkit::GaussianBlurView result; + + arg1 = (unsigned int)jarg1; + arg2 = (float)jarg2; + arg3 = (Dali::Pixel::Format)jarg3; + arg4 = (float)jarg4; + arg5 = (float)jarg5; + arg6 = jarg6 ? true : false; + { + try { + result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) { + void * jresult ; + unsigned int arg1 ; + float arg2 ; + Dali::Pixel::Format arg3 ; + float arg4 ; + float arg5 ; + Dali::Toolkit::GaussianBlurView result; + + arg1 = (unsigned int)jarg1; + arg2 = (float)jarg2; + arg3 = (Dali::Pixel::Format)jarg3; + arg4 = (float)jarg4; + arg5 = (float)jarg5; + { + try { + result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) { + Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->Add(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) { + Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->Remove(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) { + Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; + + arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; + { + try { + (arg1)->Activate(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) { + Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; + + arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; + { + try { + (arg1)->ActivateOnce(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) { + Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; + + arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; + { + try { + (arg1)->Deactivate(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) { + Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; + Dali::Texture arg2 ; + Dali::FrameBuffer arg3 ; + Dali::Texture *argp2 ; + Dali::FrameBuffer *argp3 ; + + arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; + argp2 = (Dali::Texture *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0); + return ; + } + arg2 = *argp2; + argp3 = (Dali::FrameBuffer *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0); + return ; + } + arg3 = *argp3; + { + try { + (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) { + int jresult ; + Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; + Dali::Property::Index result; + + arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; + { + try { + result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) { + void * jresult ; + Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; + Dali::FrameBuffer result; + + arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; + { + try { + result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) { + Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; + Dali::Vector4 *arg2 = 0 ; + + arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); + return ; + } + { + try { + (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) { + void * jresult ; + Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; + Dali::Vector4 result; + + arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; + { + try { + result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; + Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ; + + arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; + { + try { + result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) { + Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ; + + arg1 = (Dali::Toolkit::PageFactory *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::PageFactory *)jarg1; + { + try { + result = (unsigned int)(arg1)->GetNumberOfPages(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) { + void * jresult ; + Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ; + unsigned int arg2 ; + Dali::Texture result; + + arg1 = (Dali::Toolkit::PageFactory *)jarg1; + arg2 = (unsigned int)jarg2; + { + try { + result = (arg1)->NewPage(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Texture((const Dali::Texture &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() { + void * jresult ; + Dali::Toolkit::PageTurnView::Property *result = 0 ; + + { + try { + result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) { + Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ; + + arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() { + void * jresult ; + Dali::Toolkit::PageTurnView *result = 0 ; + + { + try { + result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::PageTurnView *arg1 = 0 ; + Dali::Toolkit::PageTurnView *result = 0 ; + + arg1 = (Dali::Toolkit::PageTurnView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ; + Dali::Toolkit::PageTurnView *arg2 = 0 ; + Dali::Toolkit::PageTurnView *result = 0 ; + + arg1 = (Dali::Toolkit::PageTurnView *)jarg1; + arg2 = (Dali::Toolkit::PageTurnView *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) { + Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ; + + arg1 = (Dali::Toolkit::PageTurnView *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::PageTurnView 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::PageTurnView::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ; + Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ; + + arg1 = (Dali::Toolkit::PageTurnView *)jarg1; + { + try { + result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ; + Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ; + + arg1 = (Dali::Toolkit::PageTurnView *)jarg1; + { + try { + result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ; + Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ; + + arg1 = (Dali::Toolkit::PageTurnView *)jarg1; + { + try { + result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ; + Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ; + + arg1 = (Dali::Toolkit::PageTurnView *)jarg1; + { + try { + result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() { + void * jresult ; + Dali::Toolkit::PageTurnLandscapeView *result = 0 ; + + { + try { + result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ; + Dali::Toolkit::PageTurnLandscapeView *result = 0 ; + + arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ; + Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ; + Dali::Toolkit::PageTurnLandscapeView *result = 0 ; + + arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1; + arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) { + Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ; + + arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::PageFactory *arg1 = 0 ; + Dali::Vector2 *arg2 = 0 ; + Dali::Toolkit::PageTurnLandscapeView result; + + arg1 = (Dali::Toolkit::PageFactory *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0); + return 0; + } + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::PageTurnLandscapeView 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::PageTurnLandscapeView::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() { + void * jresult ; + Dali::Toolkit::PageTurnPortraitView *result = 0 ; + + { + try { + result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ; + Dali::Toolkit::PageTurnPortraitView *result = 0 ; + + arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ; + Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ; + Dali::Toolkit::PageTurnPortraitView *result = 0 ; + + arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1; + arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) { + Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ; + + arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::PageFactory *arg1 = 0 ; + Dali::Vector2 *arg2 = 0 ; + Dali::Toolkit::PageTurnPortraitView result; + + arg1 = (Dali::Toolkit::PageFactory *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0); + return 0; + } + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try { + result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::PageTurnPortraitView 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::PageTurnPortraitView::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() { + void * jresult ; + Dali::Toolkit::Visual::Base *result = 0 ; + + { + try { + result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) { + Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ; + + arg1 = (Dali::Toolkit::Visual::Base *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::Visual::Base *arg1 = 0 ; + Dali::Toolkit::Visual::Base *result = 0 ; + + arg1 = (Dali::Toolkit::Visual::Base *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ; + Dali::Toolkit::Visual::Base *arg2 = 0 ; + Dali::Toolkit::Visual::Base *result = 0 ; + + arg1 = (Dali::Toolkit::Visual::Base *)jarg1; + arg2 = (Dali::Toolkit::Visual::Base *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) { + Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Visual::Base *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + (arg1)->SetName((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + + + //argout typemap for const std::string& + +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) { + char * jresult ; + Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ; + std::string *result = 0 ; + + arg1 = (Dali::Toolkit::Visual::Base *)jarg1; + { + try { + result = (std::string *) &(arg1)->GetName(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) { + Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ; + Dali::Property::Map *arg2 = 0 ; + Dali::Size arg3 ; + Dali::Size *argp3 ; + + arg1 = (Dali::Toolkit::Visual::Base *)jarg1; + arg2 = (Dali::Property::Map *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); + return ; + } + argp3 = (Dali::Size *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0); + return ; + } + arg3 = *argp3; + { + try { + (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +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)(arg1)->GetHeightForWidth(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(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)(arg1)->GetWidthForHeight(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(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); + return ; + } + { + try { + (arg1)->GetNaturalSize(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) { + Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::Visual::Base *)jarg1; + arg2 = (int)jarg2; + { + try { + (arg1)->SetDepthIndex(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) { + int jresult ; + Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ; + int result; + + arg1 = (Dali::Toolkit::Visual::Base *)jarg1; + { + try { + result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) { + Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ; + Dali::Property::Map *arg2 = 0 ; + + arg1 = (Dali::Toolkit::Visual::Base *)jarg1; + arg2 = (Dali::Property::Map *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0); + return ; + } + { + try { + ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() { + void * jresult ; + Dali::Toolkit::VisualFactory result; + + { + try { + result = Dali::Toolkit::VisualFactory::Get(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() { + void * jresult ; + Dali::Toolkit::VisualFactory *result = 0 ; + + { + try { + result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) { + Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ; + + arg1 = (Dali::Toolkit::VisualFactory *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::VisualFactory *arg1 = 0 ; + Dali::Toolkit::VisualFactory *result = 0 ; + + arg1 = (Dali::Toolkit::VisualFactory *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ; + Dali::Toolkit::VisualFactory *arg2 = 0 ; + Dali::Toolkit::VisualFactory *result = 0 ; + + arg1 = (Dali::Toolkit::VisualFactory *)jarg1; + arg2 = (Dali::Toolkit::VisualFactory *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ; + Dali::Property::Map *arg2 = 0 ; + Dali::Toolkit::Visual::Base result; + + arg1 = (Dali::Toolkit::VisualFactory *)jarg1; + arg2 = (Dali::Property::Map *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); + return 0; + } + { + try { + result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) { + void * jresult ; + Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ; + std::string *arg2 = 0 ; + Dali::ImageDimensions arg3 ; + Dali::ImageDimensions *argp3 ; + Dali::Toolkit::Visual::Base result; + + arg1 = (Dali::Toolkit::VisualFactory *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + argp3 = (Dali::ImageDimensions *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg3 = *argp3; + { + try { + result = (arg1)->CreateVisual((std::string const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() { + void * jresult ; + Dali::Toolkit::AsyncImageLoader *result = 0 ; + + { + try { + result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) { + Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ; + + arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::AsyncImageLoader *arg1 = 0 ; + Dali::Toolkit::AsyncImageLoader *result = 0 ; + + arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ; + Dali::Toolkit::AsyncImageLoader *arg2 = 0 ; + Dali::Toolkit::AsyncImageLoader *result = 0 ; + + arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1; + arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() { + void * jresult ; + Dali::Toolkit::AsyncImageLoader result; + + { + try { + result = Dali::Toolkit::AsyncImageLoader::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::AsyncImageLoader 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::AsyncImageLoader::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) { + unsigned int jresult ; + Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ; + std::string *arg2 = 0 ; + uint32_t result; + + arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try { + result = (arg1)->Load((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) { + unsigned int jresult ; + Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ; + std::string *arg2 = 0 ; + Dali::ImageDimensions arg3 ; + Dali::ImageDimensions *argp3 ; + uint32_t result; + + arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + argp3 = (Dali::ImageDimensions *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg3 = *argp3; + { + try { + result = (arg1)->Load((std::string const &)*arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, bool jarg6) { + unsigned int jresult ; + Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ; + std::string *arg2 = 0 ; + Dali::ImageDimensions arg3 ; + Dali::FittingMode::Type arg4 ; + Dali::SamplingMode::Type arg5 ; + bool arg6 ; + Dali::ImageDimensions *argp3 ; + uint32_t result; + + arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + argp3 = (Dali::ImageDimensions *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg3 = *argp3; + arg4 = (Dali::FittingMode::Type)jarg4; + arg5 = (Dali::SamplingMode::Type)jarg5; + arg6 = jarg6 ? true : false; + { + try { + result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) { + bool jresult ; + Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ; + uint32_t arg2 ; + bool result; + + arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1; + arg2 = (uint32_t)jarg2; + { + try { + result = (bool)(arg1)->Cancel(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) { + Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ; + + arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1; + { + try { + (arg1)->CancelAll(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ; + Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1; + { + try { + result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::PixelData result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + { + try { + result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PixelData((const Dali::PixelData &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::ImageDimensions arg2 ; + Dali::ImageDimensions *argp2 ; + Dali::PixelData result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + argp2 = (Dali::ImageDimensions *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PixelData((const Dali::PixelData &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) { + void * jresult ; + std::string *arg1 = 0 ; + Dali::ImageDimensions arg2 ; + Dali::FittingMode::Type arg3 ; + Dali::SamplingMode::Type arg4 ; + bool arg5 ; + Dali::ImageDimensions *argp2 ; + Dali::PixelData result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + argp2 = (Dali::ImageDimensions *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); + return 0; + } + arg2 = *argp2; + arg3 = (Dali::FittingMode::Type)jarg3; + arg4 = (Dali::SamplingMode::Type)jarg4; + arg5 = jarg5 ? true : false; + { + try { + result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::PixelData((const Dali::PixelData &)result); + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) { + Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ; + + arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * customAlgorithmInterface, void * currentFocusedActor, void * proposedActorToFocus, int direction, char * deviceName) { + void * jresult ; + Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ; + Dali::Actor arg2 ; + Dali::Actor arg3 ; + Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ; + std::string *arg5 = 0 ; + Dali::Actor *argp2 ; + Dali::Actor *argp3 ; + Dali::Actor result; + + arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)customAlgorithmInterface; + argp2 = (Dali::Actor *)currentFocusedActor; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg2 = *argp2; + argp3 = (Dali::Actor *)proposedActorToFocus; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg3 = *argp3; + arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)direction; + + std::string arg5_str(deviceName); + arg5 = &arg5_str; + + { + try { + result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4,(std::string const &)*arg5); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id, void* position) { + Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; + Dali::Vector3* vector3 = (Dali::Vector3 *)position; + return proxy->GetPosition(id, *vector3); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) { + Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; + Dali::Vector3* vector3 = (Dali::Vector3 *)position; + return proxy->SetPosition(id, *vector3); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) { + Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; + Dali::Vector3* vector3 = (Dali::Vector3 *)position; + return proxy->BakePosition(id, *vector3); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) { + Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; + Dali::Vector3* vector3 = (Dali::Vector3 *)size; + return proxy->GetSize(id, *vector3); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) { + Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; + Dali::Vector3* vector3 = (Dali::Vector3 *)size; + return proxy->SetSize(id, *vector3); +} +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) { + Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; + Dali::Vector3* vector3 = (Dali::Vector3 *)size; + return proxy->BakeSize(id, *vector3); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) { + Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; + Dali::Vector3* vector3_pos = (Dali::Vector3 *)position; + Dali::Vector3* vector3_size = (Dali::Vector3 *)size; + return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) { + Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; + Dali::Vector3* vector3 = (Dali::Vector3 *)scale; + return proxy->GetScale(id,* vector3); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) { + Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; + Dali::Vector3* vector3 = (Dali::Vector3 *)scale; + return proxy->SetScale(id, *vector3); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) { + Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; + Dali::Vector3* vector3 = (Dali::Vector3 *)scale; + return proxy->BakeScale(id, *vector3); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) { + Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; + Dali::Vector4* vector4 = (Dali::Vector4 *)color; + return proxy->GetColor(id, *vector4); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) { + Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; + Dali::Vector4* vector4 = (Dali::Vector4 *)color; + return proxy->SetColor(id, *vector4); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) { + Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; + Dali::Vector4* vector4 = (Dali::Vector4 *)color; + return proxy->BakeColor(id, *vector4); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) { + KeyboardFocusManager arg1 ; + Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ; + KeyboardFocusManager *argp1 ; + + argp1 = (KeyboardFocusManager *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0); + return ; + } + arg1 = *argp1; + arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2; + //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value. + { + try { + Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_EnableDefaultAlgorithm(void * jarg1, bool jarg2) { + KeyboardFocusManager arg1 ; + bool arg2 ; + KeyboardFocusManager *argp1 ; + + argp1 = (KeyboardFocusManager *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0); + return ; + } + arg1 = *argp1; + arg2 = jarg2; + { + try { + Dali::Toolkit::DevelKeyboardFocusManager::EnableDefaultAlgorithm(arg1, arg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_IsDefaultAlgorithmEnabled(void * jarg1) { + bool jresult ; + KeyboardFocusManager arg1 ; + KeyboardFocusManager *argp1 ; + bool result; + + argp1 = (KeyboardFocusManager *)jarg1; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0); + return false; + } + arg1 = *argp1; + { + try { + result = Dali::Toolkit::DevelKeyboardFocusManager::IsDefaultAlgorithmEnabled(arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_SetFocusFinderRootActor(void * manager, void * actor) { + if (!manager) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0); + return ; + } + if (!actor) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); + return ; + } + { + try { + Dali::Toolkit::DevelKeyboardFocusManager::SetFocusFinderRootActor(*(KeyboardFocusManager *)manager, *(Dali::Actor *)actor); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_ResetFocusFinderRootActor(void * manager) { + if (!manager) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0); + return ; + } + { + try { + Dali::Toolkit::DevelKeyboardFocusManager::ResetFocusFinderRootActor(*(KeyboardFocusManager *)manager); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1; + { + try { + result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ; + bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ; + + arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1; + arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2; + { + try { + Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ; + bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ; + + arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1; + arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2; + { + try { + Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) { + bool jresult ; + Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ; + Dali::Toolkit::AccessibilityManager *arg2 = 0 ; + bool result; + + arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1; + arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0); + return 0; + } + { + try { + result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() { + void * jresult ; + Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ; + + { + try { + result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) { + Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ; + + arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ; + void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1; + arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ; + void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1; + arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) { + Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ; + Dali::Actor arg2 ; + Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() { + void * jresult ; + Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) { + Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ; + void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ; + void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) { + Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ; + Dali::Toolkit::StyleManager arg2 ; + Dali::StyleChange::Type arg3 ; + Dali::Toolkit::StyleManager *argp2 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1; + argp2 = (Dali::Toolkit::StyleManager *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0); + return ; + } + arg2 = *argp2; + arg3 = (Dali::StyleChange::Type)jarg3; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() { + void * jresult ; + Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) { + Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ; + void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ; + void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ; + Dali::Toolkit::GaussianBlurView arg2 ; + Dali::Toolkit::GaussianBlurView *argp2 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1; + argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0); + return ; + } + arg2 = *argp2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() { + void * jresult ; + Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) { + Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ; + void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ; + void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, bool jarg4) { + Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ; + Dali::Toolkit::PageTurnView arg2 ; + unsigned int arg3 ; + bool arg4 ; + Dali::Toolkit::PageTurnView *argp2 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1; + argp2 = (Dali::Toolkit::PageTurnView *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0); + return ; + } + arg2 = *argp2; + arg3 = (unsigned int)jarg3; + arg4 = jarg4 ? true : false; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() { + void * jresult ; + Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) { + Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ; + void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ; + void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ; + Dali::Toolkit::PageTurnView arg2 ; + Dali::Toolkit::PageTurnView *argp2 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1; + argp2 = (Dali::Toolkit::PageTurnView *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0); + return ; + } + arg2 = *argp2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() { + void * jresult ; + Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) { + Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ; + void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ; + void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ; + Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1; + arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0); + return ; + } + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() { + void * jresult ; + Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) { + Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ; + void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1; + arg2 = (void (*)(Dali::Vector2 const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ; + void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1; + arg2 = (void (*)(Dali::Vector2 const &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ; + Dali::Vector2 *arg2 = 0 ; + + arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return ; + } + { + try { + Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() { + void * jresult ; + Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) { + Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ; + void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ; + void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ; + Dali::Toolkit::VideoView *arg2 = 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1; + arg2 = (Dali::Toolkit::VideoView *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0); + return ; + } + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() { + void * jresult ; + Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) { + Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ; + + { + try { + result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ; + + arg1 = (Dali::Toolkit::Ruler *)jarg1; + { + try { + result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) { + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + Dali::Toolkit::Ruler *result = 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + { + try { + result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + Dali::Toolkit::Ruler *result = 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + { + try { + result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + Dali::Toolkit::Ruler *result = 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + { + try { + result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0); + return 0; + } + { + try { + result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + arg2 = (Dali::Toolkit::Ruler *)jarg2; + { + try { + result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) { + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + { + try { + (arg1)->Reset(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) { + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + arg2 = (Dali::Toolkit::Ruler *)jarg2; + { + try { + (arg1)->Reset(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + Dali::Toolkit::Ruler *result = 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + { + try { + result = (Dali::Toolkit::Ruler *)(arg1)->Detach(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) { + float jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + float arg2 ; + float arg3 ; + float result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + { + try { + result = (float)(*arg1)->Snap(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) { + float jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + float arg2 ; + float result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (float)(*arg1)->Snap(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) { + float jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + unsigned int arg2 ; + unsigned int *arg3 = 0 ; + bool arg4 ; + float result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + arg2 = (unsigned int)jarg2; + arg3 = (unsigned int *)jarg3; + arg4 = jarg4 ? true : false; + { + try { + result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) { + unsigned int jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + float arg2 ; + bool arg3 ; + unsigned int result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + arg2 = (float)jarg2; + arg3 = jarg3 ? true : false; + { + try { + result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) { + unsigned int jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + unsigned int result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + { + try { + result = (unsigned int)(*arg1)->GetTotalPages(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) { + int jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + Dali::Toolkit::Ruler::RulerType result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + { + try { + result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) { + bool jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + bool result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + { + try { + result = (bool)(*arg1)->IsEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) { + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + { + try { + (*arg1)->Enable(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) { + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + { + try { + (*arg1)->Disable(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) { + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ; + Dali::Toolkit::RulerDomain *argp2 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + argp2 = (Dali::Toolkit::RulerDomain *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0); + return ; + } + arg2 = *argp2; + { + try { + (*arg1)->SetDomain(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) { + void * jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + Dali::Toolkit::RulerDomain *result = 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + { + try { + result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) { + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + { + try { + (*arg1)->DisableDomain(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) { + float jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + float arg2 ; + float arg3 ; + float arg4 ; + float result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + { + try { + result = (float)(*arg1)->Clamp(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) { + float jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + float arg2 ; + float arg3 ; + float result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + { + try { + result = (float)(*arg1)->Clamp(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) { + float jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + float arg2 ; + float result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (float)(*arg1)->Clamp(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) { + float jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + float arg2 ; + float arg3 ; + float arg4 ; + Dali::Toolkit::ClampState *arg5 = 0 ; + float result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + arg5 = (Dali::Toolkit::ClampState *)jarg5; + if (!arg5) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0); + return 0; + } + { + try { + result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) { + float jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + arg5 = (float)jarg5; + { + try { + result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) { + float jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + float arg2 ; + float arg3 ; + float arg4 ; + float result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + { + try { + result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) { + float jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + float arg2 ; + float arg3 ; + float result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + { + try { + result = (float)(*arg1)->SnapAndClamp(arg2,arg3); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) { + float jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + float arg2 ; + float result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + arg2 = (float)jarg2; + { + try { + result = (float)(*arg1)->SnapAndClamp(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) { + float jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + Dali::Toolkit::ClampState *arg6 = 0 ; + float result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + arg5 = (float)jarg5; + arg6 = (Dali::Toolkit::ClampState *)jarg6; + if (!arg6) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0); + return 0; + } + { + try { + result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) { + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + { + try { + (*arg1)->Reference(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) { + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + { + try { + (*arg1)->Unreference(); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) { + int jresult ; + Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; + int result; + + arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; + { + try { + result = (int)(*arg1)->ReferenceCount(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) { + bool jresult ; + Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ; + void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::Control))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ; + void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::Control))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ; + Dali::Toolkit::Control arg2 ; + Dali::Toolkit::Control *argp2 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1; + argp2 = (Dali::Toolkit::Control *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0); + return ; + } + arg2 = *argp2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() { + void * jresult ; + Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) { + Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +// Method +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) { + 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; +} + +SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *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; +} + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) { + return (Dali::RefObject *)jarg1; +} + +SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) { + return (Dali::Toolkit::Scrollable *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) { + return (Dali::Toolkit::ScrollViewEffect *)jarg1; +} + +SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) { + return (Dali::RefObject *)jarg1; +} + +SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) { + return (Dali::Toolkit::Ruler *)jarg1; +} + +SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) { + return (Dali::Toolkit::Ruler *)jarg1; +} + +SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) { + return (Dali::Toolkit::Scrollable *)jarg1; +} + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_CameraView_SWIGUpcast(Dali::Toolkit::CameraView *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) { + return (Dali::Toolkit::PageTurnView *)jarg1; +} + +SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) { + return (Dali::Toolkit::PageTurnView *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/dali-csharp-binder/dali-toolkit/devel-property-wrap.cpp b/dali-csharp-binder/dali-toolkit/devel-property-wrap.cpp new file mode 100755 index 00000000..5b8a5c19 --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/devel-property-wrap.cpp @@ -0,0 +1,606 @@ +/* + * Copyright (c) 2020 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +// INTERNAL INCLUDES +#include + +using namespace Dali; +using namespace Dali::Toolkit; +using signalType = DevelControl::VisualEventSignalType; +using visualSignalType = + Signal; +using SignalCallbackFuncType = void (*)(Control, Property::Index, + Property::Index); + +SWIGINTERN bool _CSharp_Dali_VisualEventSignal_Empty(signalType const *self) { + return self->Empty(); +} +SWIGINTERN std::size_t +_CSharp_Dali_VisualEventSignal_GetConnectionCount(signalType *self) { + return self->GetConnectionCount(); +} +SWIGINTERN void +_CSharp_Dali_VisualEventSignal_Connect(signalType *self, + SignalCallbackFuncType func) { + self->Connect(func); +} +SWIGINTERN void +_CSharp_Dali_VisualEventSignal_Disconnect(signalType *self, + SignalCallbackFuncType func) { + self->Disconnect(func); +} +SWIGINTERN void _CSharp_Dali_VisualEventSignal_Emit(signalType *self, + Control arg1, + Property::Index arg2, + Property::Index arg3) { + self->Emit(arg1, arg2, arg3); +} + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_TOOLTIP_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelControl::Property::TOOLTIP; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_STATE_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelControl::Property::STATE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_SUB_STATE_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelControl::Property::SUB_STATE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_LEFT_FOCUSABLE_ACTOR_ID_get() { + return Dali::Toolkit::DevelControl::Property::LEFT_FOCUSABLE_ACTOR_ID; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_RIGHT_FOCUSABLE_ACTOR_ID_get() { + return Dali::Toolkit::DevelControl::Property::RIGHT_FOCUSABLE_ACTOR_ID; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_UP_FOCUSABLE_ACTOR_ID_get() { + return Dali::Toolkit::DevelControl::Property::UP_FOCUSABLE_ACTOR_ID; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_DOWN_FOCUSABLE_ACTOR_ID_get() { + return Dali::Toolkit::DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_CLOCKWISE_FOCUSABLE_ACTOR_ID_get() { + return Dali::Toolkit::DevelControl::Property::CLOCKWISE_FOCUSABLE_ACTOR_ID; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_COUNTER_CLOCKWISE_FOCUSABLE_ACTOR_ID_get() { + return Dali::Toolkit::DevelControl::Property::COUNTER_CLOCKWISE_FOCUSABLE_ACTOR_ID; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_ItemView_Property_LAYOUT_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::ItemView::Property::LAYOUT; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Visual_Property_TRANSFORM_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::Visual::Property::TRANSFORM; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Visual_Property_PREMULTIPLIED_ALPHA_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::Visual::Property::PREMULTIPLIED_ALPHA; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Visual_Property_MIX_COLOR_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::Visual::Property::MIX_COLOR; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextLabel_Property_PIXEL_SIZE_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::PIXEL_SIZE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextLabel_Property_ELLIPSIS_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::ELLIPSIS; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_TextLabel_Property_AUTO_SCROLL_STOP_MODE_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_STOP_MODE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_TextLabel_Property_AUTO_SCROLL_LOOP_DELAY_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_DELAY; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_HIDDENINPUT_PROPERTY_MODE_get() { + int jresult; + int result; + + { + try { + result = (int)Dali::Toolkit::HiddenInput::Property::MODE; + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_HIDDENINPUT_PROPERTY_SUBSTITUTE_CHARACTER_get() { + int jresult; + int result; + + { + try { + result = (int)Dali::Toolkit::HiddenInput::Property::SUBSTITUTE_CHARACTER; + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_HIDDENINPUT_PROPERTY_SUBSTITUTE_COUNT_get() { + int jresult; + int result; + + { + try { + result = (int)Dali::Toolkit::HiddenInput::Property::SUBSTITUTE_COUNT; + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_HIDDENINPUT_PROPERTY_SHOW_LAST_CHARACTER_DURATION_get() { + int jresult; + int result; + + { + try { + result = (int) + Dali::Toolkit::HiddenInput::Property::SHOW_LAST_CHARACTER_DURATION; + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextLabel_Property_LINE_COUNT_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::LINE_COUNT; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextLabel_Property_LINE_WRAP_MODE_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::TextLabel::Property::LINE_WRAP_MODE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextLabel_Property_TEXT_DIRECTION_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelTextLabel::Property::TEXT_DIRECTION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_TextLabel_Property_VERTICAL_LINE_ALIGNMENT_get() { + int jresult; + int result; + + result = + (int)Dali::Toolkit::DevelTextLabel::Property::VERTICAL_LINE_ALIGNMENT; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_TextLabel_Property_MATCH_SYSTEM_LANGUAGE_DIRECTION_get() { + int jresult; + int result; + + result = (int) + Dali::Toolkit::DevelTextLabel::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextLabel_Property_MIN_LINE_SIZE_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelTextLabel::Property::MIN_LINE_SIZE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelTextLabel::Property::RENDERING_BACKEND; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextLabel_Property_ELLIPSIS_POSITION_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelTextLabel::Property::ELLIPSIS_POSITION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_LINE_WRAP_MODE_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::LINE_WRAP_MODE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_ELLIPSIS_POSITION_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::ELLIPSIS_POSITION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_MIN_LINE_SIZE_get() { + return (int)Dali::Toolkit::DevelTextEditor::Property::MIN_LINE_SIZE; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_ELLIPSIS_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::ELLIPSIS; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_ELLIPSIS_POSITION_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelTextField::Property::ELLIPSIS_POSITION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_STRIKETHROUGH_get() { + return (int)Dali::Toolkit::DevelTextEditor::Property::STRIKETHROUGH; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_STRIKETHROUGH_get() { + return (int)Dali::Toolkit::DevelTextField::Property::STRIKETHROUGH; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_STRIKETHROUGH_get() { + return (int)Dali::Toolkit::DevelTextLabel::Property::STRIKETHROUGH; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_Dali_TextEditor_Property_CHARACTER_SPACING_get() { + return (int)Dali::Toolkit::DevelTextEditor::Property::CHARACTER_SPACING; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_Dali_TextField_Property_CHARACTER_SPACING_get() { + return (int)Dali::Toolkit::DevelTextField::Property::CHARACTER_SPACING; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_Dali_TextLabel_Property_CHARACTER_SPACING_get() { + return (int)Dali::Toolkit::DevelTextLabel::Property::CHARACTER_SPACING; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_Dali_TextSelectionPopup_Property_POPUP_MAX_SIZE_get() { + return (int)Dali::Toolkit::TextSelectionPopup::Property::POPUP_MAX_SIZE; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_Dali_TextSelectionPopup_Property_OPTION_DIVIDER_SIZE_get() { + return (int)Dali::Toolkit::TextSelectionPopup::Property::OPTION_DIVIDER_SIZE; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_Dali_TextSelectionPopup_Property_OPTION_DIVIDER_PADDING_get() { + return (int)Dali::Toolkit::TextSelectionPopup::Property::OPTION_DIVIDER_PADDING; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_Dali_TextSelectionPopup_Property_LABEL_MINIMUM_SIZE_get() { + return (int)Dali::Toolkit::TextSelectionPopup::Property::LABEL_MINIMUM_SIZE; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_Dali_TextSelectionPopup_Property_LABEL_PADDING_get() { + return (int)Dali::Toolkit::TextSelectionPopup::Property::LABEL_PADDING; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_Dali_TextSelectionPopup_Property_LABEL_TEXT_VISUAL_get() { + return (int)Dali::Toolkit::TextSelectionPopup::Property::LABEL_TEXT_VISUAL; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_Dali_TextSelectionPopup_Property_ENABLE_SCROLL_BAR_get() { + return (int)Dali::Toolkit::TextSelectionPopup::Property::ENABLE_SCROLL_BAR; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_Dali_TextSelectionPopup_Property_POPUP_DIVIDER_COLOR_get() { + return (int)Dali::Toolkit::TextSelectionPopup::Property::POPUP_DIVIDER_COLOR; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_Dali_TextSelectionPopup_Property_POPUP_PRESSED_COLOR_get() { + return (int)Dali::Toolkit::TextSelectionPopup::Property::POPUP_PRESSED_COLOR; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_Dali_TextSelectionPopup_Property_POPUP_PRESSED_CORNER_RADIUS_get() { + return (int)Dali::Toolkit::TextSelectionPopup::Property::POPUP_PRESSED_CORNER_RADIUS; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_Dali_TextSelectionPopup_Property_POPUP_FADE_IN_DURATION_get() { + return (int)Dali::Toolkit::TextSelectionPopup::Property::POPUP_FADE_IN_DURATION; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_Dali_TextSelectionPopup_Property_POPUP_FADE_OUT_DURATION_get() { + return (int)Dali::Toolkit::TextSelectionPopup::Property::POPUP_FADE_OUT_DURATION; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_Dali_TextSelectionPopup_Property_BACKGROUND_get() { + return (int)Dali::Toolkit::TextSelectionPopup::Property::BACKGROUND; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_Dali_TextSelectionPopup_Property_BACKGROUND_BORDER_get() { + return (int)Dali::Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER; +} + +SWIGEXPORT unsigned int SWIGSTDCALL +CSharp_Dali_VisualEventSignal_Empty(void *jarg1) { + unsigned int jresult; + signalType *arg1 = (signalType *)0; + bool result; + + arg1 = (signalType *)jarg1; + { + try { + result = (bool)_CSharp_Dali_VisualEventSignal_Empty((signalType *)arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +SWIGEXPORT unsigned long SWIGSTDCALL +CSharp_Dali_VisualEventSignal_GetConnectionCount(void *jarg1) { + unsigned long jresult; + signalType *arg1 = (signalType *)0; + std::size_t result; + + arg1 = (signalType *)jarg1; + { + try { + result = + _CSharp_Dali_VisualEventSignal_GetConnectionCount((signalType *)arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualEventSignal_Connect(void *jarg1, + void *jarg2) { + signalType *arg1 = (signalType *)0; + SignalCallbackFuncType arg2 = (SignalCallbackFuncType)0; + + arg1 = (signalType *)jarg1; + arg2 = (SignalCallbackFuncType)jarg2; + { + try { + _CSharp_Dali_VisualEventSignal_Connect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_VisualEventSignal_Disconnect(void *jarg1, void *jarg2) { + signalType *arg1 = (signalType *)0; + SignalCallbackFuncType arg2 = (SignalCallbackFuncType)0; + + arg1 = (signalType *)jarg1; + arg2 = (SignalCallbackFuncType)jarg2; + { + try { + _CSharp_Dali_VisualEventSignal_Disconnect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualEventSignal_Emit(void *jarg1, + void *jarg2, + int jarg3, + int jarg4) { + signalType *arg1 = (signalType *)0; + Control *arg2 = (Control *)0; + Dali::Property::Index arg3 = 0; + Dali::Property::Index arg4 = 0; + + arg1 = (signalType *)jarg1; + arg2 = (Control *)jarg2; + arg3 = (Dali::Property::Index)jarg3; + arg4 = (Dali::Property::Index)jarg4; + { + try { + _CSharp_Dali_VisualEventSignal_Emit(arg1, *arg2, arg3, arg4); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_VisualEventSignal() { + void *jresult; + signalType *result = 0; + + { + try { + result = (signalType *)new Dali::Signal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualEventSignal(void *jarg1) { + signalType *arg1 = (signalType *)0; + + arg1 = (signalType *)jarg1; + { + try { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_View_VisualEventSignal(void *jarg1) { + void *jresult; + Control *arg1 = (Dali::Toolkit::Control *)0; + visualSignalType *result; + + arg1 = (Dali::Toolkit::Control *)jarg1; + { + try { + result = (visualSignalType *)&(DevelControl::VisualEventSignal(*arg1)); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)(result); + return jresult; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/fade-transition-wrap.cpp b/dali-csharp-binder/dali-toolkit/fade-transition-wrap.cpp new file mode 100755 index 00000000..b364261f --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/fade-transition-wrap.cpp @@ -0,0 +1,131 @@ +/* + * Copyright (c) 2021 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_FadeTransition() + { + void *jresult; + Dali::Toolkit::FadeTransition *result = 0; + + { + try + { + result = (Dali::Toolkit::FadeTransition *)new Dali::Toolkit::FadeTransition(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_FadeTransition_New(void *nuiControl, float nuiOpaicty, void *nuiTimePeriod) + { + void *jresult; + Dali::Toolkit::Control *control = (Dali::Toolkit::Control *)nuiControl; + float opacity = nuiOpaicty; + Dali::TimePeriod *timePeriod = (Dali::TimePeriod *)nuiTimePeriod; + + Dali::Toolkit::FadeTransition result; + + { + try + { + result = Dali::Toolkit::FadeTransition::New(*control, opacity, *timePeriod); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::FadeTransition((const Dali::Toolkit::FadeTransition &)result); + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FadeTransition(void *nuiFadeTransition) + { + Dali::Toolkit::FadeTransition *fade = (Dali::Toolkit::FadeTransition *)0; + + fade = (Dali::Toolkit::FadeTransition *)nuiFadeTransition; + { + try + { + delete fade; + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_FadeTransition_Set(void *nuiFadeTransition) + { + Dali::Toolkit::FadeTransition *newFadeTransition = 0; + Dali::Toolkit::FadeTransition *fade = (Dali::Toolkit::FadeTransition *)nuiFadeTransition; + if (!fade) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FadeTransition const & type is null", 0); + return 0; + } + { + try + { + newFadeTransition = (Dali::Toolkit::FadeTransition *)new Dali::Toolkit::FadeTransition((Dali::Toolkit::FadeTransition const &)*fade); + } + CALL_CATCH_EXCEPTION(0); + } + void *result; + result = (void *)newFadeTransition; + return result; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_FadeTransition_Assign(void *nuiDestination, void *nuiSource) + { + void *jresult; + Dali::Toolkit::FadeTransition *destination = (Dali::Toolkit::FadeTransition *)0; + Dali::Toolkit::FadeTransition *source = 0; + Dali::Toolkit::FadeTransition *result = 0; + + destination = (Dali::Toolkit::FadeTransition *)nuiDestination; + source = (Dali::Toolkit::FadeTransition *)nuiSource; + + if (!source) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FadeTransition const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Toolkit::FadeTransition *)&(destination)->operator=((Dali::Toolkit::FadeTransition const &)*source); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/flex-layout-wrap.cpp b/dali-csharp-binder/dali-toolkit/flex-layout-wrap.cpp new file mode 100755 index 00000000..6721984f --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/flex-layout-wrap.cpp @@ -0,0 +1,654 @@ +/* + * Copyright (c) 2021 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexLayout_New() +{ + Dali::Toolkit::Flex::Node* result = (Dali::Toolkit::Flex::Node*)0; + { + try { + result = new Dali::Toolkit::Flex::Node(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); + }; + } + } + return (void *)result; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexLayout(void * jarg1) +{ + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + { + try { + delete arg1; + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); + }; + } + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexDirection(void * jarg1, int jarg2) +{ + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + Dali::Toolkit::Flex::FlexDirection arg2 ; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + arg2 = (Dali::Toolkit::Flex::FlexDirection)jarg2; + { + try { + arg1->Dali::Toolkit::Flex::Node::SetFlexDirection( arg2); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); + }; + } + } +} + +SWIGEXPORT const Dali::Toolkit::Flex::Node* SWIGSTDCALL CSharp_Dali_FlexLayout_AddChildWithMargin(void * jarg1, void *jarg2, void *jarg3, Dali::Toolkit::Flex::MeasureCallback jarg4, int jarg5) +{ + Dali::Toolkit::Flex::Node* arg1 = (Dali::Toolkit::Flex::Node* )jarg1; + Dali::Actor *arg2 = (Dali::Actor *) 0; arg2 = (Dali::Actor *)jarg2; + const Dali::Toolkit::Flex::Node* result = nullptr; + + { + try { + if(jarg3 == NULL) + { + result = arg1->Dali::Toolkit::Flex::Node::AddChild((Dali::Actor &)*arg2, Dali::Extents(0,0,0,0), jarg4, jarg5); + } + else + { + Dali::Extents* arg3 = (Dali::Extents *)jarg3; + result = arg1->Dali::Toolkit::Flex::Node::AddChild((Dali::Actor &)*arg2, *arg3, jarg4, jarg5); + } + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); + }; + } + } + return result; +} + +SWIGEXPORT const Dali::Toolkit::Flex::Node* SWIGSTDCALL CSharp_Dali_FlexLayout_AddChild(void * jarg1, void *jarg2, Dali::Toolkit::Flex::MeasureCallback jarg3, int jarg4) +{ + return CSharp_Dali_FlexLayout_AddChildWithMargin(jarg1,jarg2,NULL,jarg3,jarg4); +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_RemoveChild(void * jarg1, void * jarg2) +{ + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + Dali::Actor* arg2 = (Dali::Actor *)jarg2; + + arg1 = (Dali::Toolkit::Flex::Node*)jarg1; + { + try { + arg1->Dali::Toolkit::Flex::Node::RemoveChild(*arg2); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); + }; + } + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_CalculateLayout(void * jarg1, float jarg2, float jarg3, bool isRtl ) +{ + Dali::Toolkit::Flex::Node * arg1 = (Dali::Toolkit::Flex::Node* )jarg1; + { + try { + arg1->Dali::Toolkit::Flex::Node::CalculateLayout(jarg2, jarg3, isRtl); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); + }; + } + } +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetWidth(void * jarg1 ) +{ + Dali::Toolkit::Flex::Node* arg1 = (Dali::Toolkit::Flex::Node* )jarg1 ; + float result = 0.0f; + { + try { + result = arg1->Dali::Toolkit::Flex::Node::GetFlexWidth(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); + }; + } + } + return result; +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetHeight(void * jarg1 ) +{ + float result = 0.0f; + Dali::Toolkit::Flex::Node* arg1 = (Dali::Toolkit::Flex::Node* )jarg1 ; + { + try { + result = arg1->Dali::Toolkit::Flex::Node::GetFlexHeight(); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); + }; + } + } + return result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_FlexLayout_GetNodeFrame( void * jarg1, int index ) +{ + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + Dali::Vector4 result; + void* jresult; + { + try { + result = arg1->Dali::Toolkit::Flex::Node::GetNodeFrame(index); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); + }; + } + } + + jresult = new Dali::Vector4((const Dali::Vector4 &)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetMargin(void * jarg1, void * jarg2) +{ + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + Dali::Extents* arg2 = (Dali::Extents *)jarg2; + { + try { + arg1->Dali::Toolkit::Flex::Node::SetMargin( *arg2); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); + }; + } + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetPadding(void * jarg1, void * jarg2) +{ + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + Dali::Extents* arg2 = (Dali::Extents *)jarg2; + { + try { + arg1->Dali::Toolkit::Flex::Node::SetPadding( *arg2); + } catch (std::out_of_range& e) { + { + SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); + }; + } catch (std::exception& e) { + { + SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); + }; + } catch (...) { + { + SWIG_CSharpException(SWIG_UnknownError, "unknown error"); + }; + } + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexDirection(void * jarg1) +{ + int jresult ; + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + Dali::Toolkit::Flex::FlexDirection result; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + { + try { + result = (Dali::Toolkit::Flex::FlexDirection)arg1->Dali::Toolkit::Flex::Node::GetFlexDirection(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexJustification(void * jarg1, int jarg2) +{ + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + Dali::Toolkit::Flex::Justification arg2 ; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + arg2 = (Dali::Toolkit::Flex::Justification)jarg2; + { + try { + arg1->Dali::Toolkit::Flex::Node::SetFlexJustification(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexJustification(void * jarg1) +{ + int jresult ; + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + Dali::Toolkit::Flex::Justification result; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + { + try { + result = (Dali::Toolkit::Flex::Justification)arg1->Dali::Toolkit::Flex::Node::GetFlexJustification(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexWrap(void * jarg1, int jarg2) +{ + + Dali::Toolkit::Flex::Node* arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + Dali::Toolkit::Flex::WrapType arg2 = (Dali::Toolkit::Flex::WrapType)jarg2; + { + try { + arg1->Dali::Toolkit::Flex::Node::SetFlexWrap(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexWrap(void * jarg1) +{ + int jresult ; + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + Dali::Toolkit::Flex::WrapType result; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + { + try { + result = (Dali::Toolkit::Flex::WrapType)arg1->Dali::Toolkit::Flex::Node::GetFlexWrap(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexAlignment(void * jarg1, int jarg2) +{ + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + Dali::Toolkit::Flex::Alignment arg2 ; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + arg2 = (Dali::Toolkit::Flex::Alignment)jarg2; + { + try { + arg1->Dali::Toolkit::Flex::Node::SetFlexAlignment(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexAlignment(void * jarg1) +{ + int jresult ; + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + Dali::Toolkit::Flex::Alignment result; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + { + try { + result = (Dali::Toolkit::Flex::Alignment)arg1->Dali::Toolkit::Flex::Node::GetFlexAlignment(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexItemsAlignment(void * jarg1, int jarg2) +{ + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + Dali::Toolkit::Flex::Alignment arg2 ; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + arg2 = (Dali::Toolkit::Flex::Alignment)jarg2; + { + try { + arg1->Dali::Toolkit::Flex::Node::SetFlexItemsAlignment(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexItemsAlignment(void * jarg1) +{ + int jresult ; + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + Dali::Toolkit::Flex::Alignment result; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + { + try { + result = (Dali::Toolkit::Flex::Alignment)arg1->Dali::Toolkit::Flex::Node::GetFlexItemsAlignment(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexAlignmentSelf(void * jarg1, int jarg2) +{ + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + Dali::Toolkit::Flex::Alignment arg2 ; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + arg2 = (Dali::Toolkit::Flex::Alignment)jarg2; + { + try { + arg1->Dali::Toolkit::Flex::Node::SetFlexAlignmentSelf(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexAlignmentSelf(void * jarg1) +{ + int jresult ; + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + Dali::Toolkit::Flex::Alignment result; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + { + try { + result = (Dali::Toolkit::Flex::Alignment)arg1->Dali::Toolkit::Flex::Node::GetFlexAlignmentSelf(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexPositionType(void * jarg1, int jarg2) +{ + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + Dali::Toolkit::Flex::PositionType arg2 ; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + arg2 = (Dali::Toolkit::Flex::PositionType)jarg2; + { + try { + arg1->Dali::Toolkit::Flex::Node::SetFlexPositionType(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexPositionType(void * jarg1) +{ + int jresult ; + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + Dali::Toolkit::Flex::PositionType result; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + { + try { + result = (Dali::Toolkit::Flex::PositionType)arg1->Dali::Toolkit::Flex::Node::GetFlexPositionType(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexAspectRatio(void * jarg1, float jarg2) +{ + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + arg2 = (float)jarg2; + { + try { + arg1->Dali::Toolkit::Flex::Node::SetFlexAspectRatio(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexAspectRatio(void * jarg1) +{ + int jresult ; + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + float result; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + { + try { + result = (float)arg1->Dali::Toolkit::Flex::Node::GetFlexAspectRatio(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (float)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexBasis(void * jarg1, float jarg2) +{ + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + arg2 = (float)jarg2; + { + try { + arg1->Dali::Toolkit::Flex::Node::SetFlexBasis(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexBasis(void * jarg1) +{ + int jresult ; + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + float result; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + { + try { + result = (float)arg1->Dali::Toolkit::Flex::Node::GetFlexBasis(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (float)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexShrink(void * jarg1, float jarg2) +{ + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + arg2 = (float)jarg2; + { + try { + arg1->Dali::Toolkit::Flex::Node::SetFlexShrink(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexShrink(void * jarg1) +{ + int jresult ; + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + float result; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + { + try { + result = (float)arg1->Dali::Toolkit::Flex::Node::GetFlexShrink(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (float)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexGrow(void * jarg1, float jarg2) +{ + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + arg2 = (float)jarg2; + { + try { + arg1->Dali::Toolkit::Flex::Node::SetFlexGrow(arg2); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexGrow(void * jarg1) +{ + int jresult ; + Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; + float result; + + arg1 = (Dali::Toolkit::Flex::Node *)jarg1; + { + try { + result = (float)arg1->Dali::Toolkit::Flex::Node::GetFlexGrow(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (float)result; + return jresult; +} + + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/gl-view-wrap.cpp b/dali-csharp-binder/dali-toolkit/gl-view-wrap.cpp new file mode 100644 index 00000000..28b95fc7 --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/gl-view-wrap.cpp @@ -0,0 +1,378 @@ +/* + * Copyright (c) 2021 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /*GlView binding*/ + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlView_New_SWIG(int nuiColorFormat) + { + void *jresult; + Dali::Toolkit::GlView result; + + Dali::Toolkit::GlView::ColorFormat colorFormat; + colorFormat = static_cast(nuiColorFormat); + { + try + { + result = Dali::Toolkit::GlView::New(colorFormat); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::GlView((const Dali::Toolkit::GlView &)result); + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlView_New2_SWIG(int nuiBackendMode, int nuiColorFormat) + { + void *jresult; + Dali::Toolkit::GlView result; + + Dali::Toolkit::GlView::ColorFormat colorFormat; + Dali::Toolkit::GlView::BackendMode backendMode; + colorFormat = static_cast(nuiColorFormat); + backendMode = static_cast(nuiBackendMode); + { + try + { + + result = Dali::Toolkit::GlView::New(backendMode, colorFormat); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::GlView((const Dali::Toolkit::GlView &)result); + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlView_SWIG_0() + { + void *jresult; + Dali::Toolkit::GlView *result = nullptr; + + { + try + { + result = (Dali::Toolkit::GlView *)new Dali::Toolkit::GlView(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlView_SWIG_1(void *nuiGlView) + { + void *jresult; + Dali::Toolkit::GlView *glView = nullptr; + Dali::Toolkit::GlView *result = nullptr; + + glView = (Dali::Toolkit::GlView *)nuiGlView; + if (!glView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GlView const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Toolkit::GlView *)new Dali::Toolkit::GlView((Dali::Toolkit::GlView const &)*glView); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GlView(void *nuiGlView) + { + Dali::Toolkit::GlView *glView = nullptr; + + glView = (Dali::Toolkit::GlView *)nuiGlView; + { + try + { + delete glView; + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlView_Assign(void *nuiGlView1, void *nuiGlView2) + { + void *jresult; + Dali::Toolkit::GlView *glView1 = nullptr; + Dali::Toolkit::GlView *glView2 = nullptr; + Dali::Toolkit::GlView *result = nullptr; + + glView1 = (Dali::Toolkit::GlView *)nuiGlView1; + glView2 = (Dali::Toolkit::GlView *)nuiGlView2; + if (!glView2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GlView const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Toolkit::GlView *)&(glView1)->operator=((Dali::Toolkit::GlView const &)*glView2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlView_SetGraphicsConfig(void *nuiGlView, bool nuiDepth, bool nuiStencil, int nuiMsaa, int nuiVersion) + { + Dali::Toolkit::GlView *glView = nullptr; + Dali::Toolkit::GlView::GraphicsApiVersion version; + + glView = (Dali::Toolkit::GlView *)nuiGlView; + version = static_cast(nuiVersion); + { + try + { + (glView)->SetGraphicsConfig(nuiDepth, nuiStencil, nuiMsaa, version); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlView_RegisterGlCallbacks(void *nuiGlView, void *nuiInitCB, int *nuiRenderFrameCB, void *nuiTerminateCB) + { + Dali::Toolkit::GlView *glView = (Dali::Toolkit::GlView *)nuiGlView; + void (*initCB)() = (void (*)())nuiInitCB; + int (*renderFrameCB)() = (int (*)())nuiRenderFrameCB; + void (*terminateCB)() = (void (*)())nuiTerminateCB; + + if (!glView || !initCB || !renderFrameCB || !terminateCB) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null", 0); + return; + } + try + { + glView->RegisterGlCallbacks(Dali::MakeCallback(initCB), Dali::MakeCallback(renderFrameCB), Dali::MakeCallback(terminateCB)); + } + CALL_CATCH_EXCEPTION(); + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlView_SetResizeCallback(void *nuiGlView, void *nuiResizeCB) + { + Dali::Toolkit::GlView *glView = (Dali::Toolkit::GlView *)nuiGlView; + void (*resizeCB)(int, int) = (void (*)(int, int))nuiResizeCB; + + if (!glView || !resizeCB) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null", 0); + return; + } + try + { + glView->SetResizeCallback(Dali::MakeCallback(resizeCB)); + } + CALL_CATCH_EXCEPTION(); + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlView_RenderOnce(void *nuiGlView) + { + Dali::Toolkit::GlView *glView = (Dali::Toolkit::GlView *)nuiGlView; + if (!glView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GlView", 0); + return; + } + { + try + { + glView->RenderOnce(); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlView_BindTextureResources(void *nuiGlView, void *textures, int size) + { + Dali::Toolkit::GlView *glView = (Dali::Toolkit::GlView *)nuiGlView; + Dali::Texture **texPtr = (Dali::Texture **)textures; + if (!glView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GlView", 0); + return; + } + { + try + { + // Convert array to vector + std::vector vTex; + for (int i = 0; i < size; i++) + { + Dali::Texture texture = *texPtr[i]; + vTex.push_back(texture); + } + glView->BindTextureResources(vTex); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GlView_GetRenderingMode(void *nuiGlView) + { + int jresult; + Dali::Toolkit::GlView *glView = nullptr; + Dali::Toolkit::GlView::RenderingMode result; + + glView = (Dali::Toolkit::GlView *)nuiGlView; + if (!glView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GlView", 0); + return 0; + } + + { + try + { + result = (Dali::Toolkit::GlView::RenderingMode)(glView)->GetRenderingMode(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlView_SetRenderingMode(void *nuiGlView, int nuiRenderingMode) + { + Dali::Toolkit::GlView *glView = nullptr; + Dali::Toolkit::GlView::RenderingMode renderingMode; + + glView = (Dali::Toolkit::GlView *)nuiGlView; + if (!glView) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GlView", 0); + return; + } + renderingMode = (Dali::Toolkit::GlView::RenderingMode)nuiRenderingMode; + { + try + { + (glView)->SetRenderingMode(renderingMode); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GlView_GetBackendMode(void *nuiGlView) + { + int jresult; + Dali::Toolkit::GlView *glView = nullptr; + Dali::Toolkit::GlView::BackendMode result; + + glView = (Dali::Toolkit::GlView *)nuiGlView; + if (!glView) + { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::Toolkit::GlView", 0); + return 0; + } + + { + try + { + result = (Dali::Toolkit::GlView::BackendMode)(glView)->GetBackendMode(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (int)result; + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_RenderCallbackInput_Size_get(void *input) + { + void *jresult; + Dali::Size *result = 0; + Dali::RenderCallbackInput *renderInput = (Dali::RenderCallbackInput *)input; + + result = &(renderInput->size); + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_RenderCallbackInput_Mvp_get(void *input) + { + void *jresult; + Dali::Matrix *result = 0; + Dali::RenderCallbackInput *renderInput = (Dali::RenderCallbackInput *)input; + + result = &(renderInput->mvp); + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_RenderCallbackInput_Projection_get(void *input) + { + void *jresult; + Dali::Matrix *result = 0; + Dali::RenderCallbackInput *renderInput = (Dali::RenderCallbackInput *)input; + + result = &(renderInput->projection); + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_RenderCallbackInput_ClippingBox_get(void *input) + { + void *jresult; + Dali::Rect *result = 0; + Dali::RenderCallbackInput *renderInput = (Dali::RenderCallbackInput *)input; + + result = &(renderInput->clippingBox); + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_RenderCallbackInput_TextureBindings_get(void *input, int *size) + { + void *jresult; + uint *result = 0; + Dali::RenderCallbackInput *renderInput = (Dali::RenderCallbackInput *)input; + + result = renderInput->textureBindings.data(); + *size = renderInput->textureBindings.size(); + jresult = (void *)result; + return jresult; + } + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/internal-visual-property-get-set-wrap.cpp b/dali-csharp-binder/dali-toolkit/internal-visual-property-get-set-wrap.cpp new file mode 100755 index 00000000..4c1414e0 --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/internal-visual-property-get-set-wrap.cpp @@ -0,0 +1,378 @@ +/* + * Copyright (c) 2022 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include +#include +#include +#include +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); + extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + + enum InternalPropertyReturnType + { + NO_ERROR = 0, + ERROR_UNKNOWN = 1, + ERROR_IMPOSSIBLE_SET = 2, + }; + + // Update visual property by Action::UPDATE_PROPERTY. + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_InternalUpdateVisualPropertyBool(void *view, int visualIndex, int visualPropertyIndex, bool valBool) + { + Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; + + if (!pControl) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + Dali::Property::Map tempMap; + tempMap.Insert(visualPropertyIndex, valBool); + Dali::Toolkit::DevelControl::DoAction(*pControl, visualIndex, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, std::move(tempMap)); + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_InternalUpdateVisualPropertyFloat(void *view, int visualIndex, int visualPropertyIndex, float valFloat) + { + Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; + + if (!pControl) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + Dali::Property::Map tempMap; + tempMap.Insert(visualPropertyIndex, valFloat); + Dali::Toolkit::DevelControl::DoAction(*pControl, visualIndex, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, std::move(tempMap)); + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_InternalUpdateVisualPropertyInt(void *view, int visualIndex, int visualPropertyIndex, int valInt) + { + Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; + + if (!pControl) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + Dali::Property::Map tempMap; + tempMap.Insert(visualPropertyIndex, valInt); + Dali::Toolkit::DevelControl::DoAction(*pControl, visualIndex, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, std::move(tempMap)); + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_InternalUpdateVisualPropertyIntPair(void *view, int visualIndex, int visualPropertyIndex, int valInt1, int valInt2) + { + Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; + + if (!pControl) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + Dali::Property::Array tempArray; + tempArray.Add(Dali::Property::Value(valInt1)); + tempArray.Add(Dali::Property::Value(valInt2)); + Dali::Property::Map tempMap; + tempMap.Insert(visualPropertyIndex, std::move(tempArray)); + Dali::Toolkit::DevelControl::DoAction(*pControl, visualIndex, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, std::move(tempMap)); + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_InternalUpdateVisualPropertyString(void *view, int visualIndex, int visualPropertyIndex, char* valString) + { + Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; + + if (!pControl) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + if (!valString) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "valString1 is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + Dali::Property::Map tempMap; + tempMap.Insert(visualPropertyIndex, std::move(valString)); + Dali::Toolkit::DevelControl::DoAction(*pControl, visualIndex, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, std::move(tempMap)); + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_InternalUpdateVisualPropertyStringPair(void *view, int visualIndex, int visualPropertyIndex, char* valString1, char* valString2) + { + Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; + + if (!pControl) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + if (!valString1) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "valString1 is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + if (!valString2) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "valString2 is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + Dali::Property::Array tempArray; + tempArray.Add(Dali::Property::Value(valString1)); + tempArray.Add(Dali::Property::Value(valString2)); + Dali::Property::Map tempMap; + tempMap.Insert(visualPropertyIndex, std::move(tempArray)); + Dali::Toolkit::DevelControl::DoAction(*pControl, visualIndex, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, std::move(tempMap)); + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_InternalUpdateVisualPropertyVector4(void *view, int visualIndex, int visualPropertyIndex, void *vector4) + { + Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; + const Dali::Vector4 *pVector4 = (const Dali::Vector4 *)vector4; + + if (!pControl) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + if (!pVector4) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector4 is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + Dali::Property::Map tempMap; + tempMap.Insert(visualPropertyIndex, *pVector4); + Dali::Toolkit::DevelControl::DoAction(*pControl, visualIndex, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, std::move(tempMap)); + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + // Other Actions witch is not Action::UPDATE_PROPERTY. + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoActionWithEmptyAttributes(void *view, int visualIndex, int actionId) + { + Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; + + if (!pControl) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0); + return; + } + { + try { + Dali::Toolkit::DevelControl::DoAction(*pControl, visualIndex, actionId, Dali::Property::Value()); + } CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoActionWithSingleIntAttributes(void *view, int visualIndex, int actionId, int actionValue) + { + Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; + + if (!pControl) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0); + return; + } + { + try { + Dali::Toolkit::DevelControl::DoAction(*pControl, visualIndex, actionId, Dali::Property::Value(actionValue)); + } CALL_CATCH_EXCEPTION(); + } + } + + // Get value from visual + // NOTE : Control.GetProperty(visualIndex) is not enought because it cannot get custom registed visual. + // NOTE : Currently, there is no way to get value from visual directly. We need to use CreatePropertyMap. + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalRetrievingVisualPropertyInt(void *view, int visualIndex, int visualPropertyIndex, int *valInt) + { + Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; + + if (!pControl) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + if (!valInt) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "valInt is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + Dali::Toolkit::Internal::Control& internalControl = Dali::Toolkit::Internal::GetImplementation(*pControl); + Dali::Toolkit::Visual::Base visualBase = Dali::Toolkit::DevelControl::GetVisual(internalControl, visualIndex); + if(visualBase) + { + Dali::Property::Map tempMap; + visualBase.CreatePropertyMap(tempMap); + Dali::Property::Value* retValuePtr = tempMap.Find(visualPropertyIndex); + if(retValuePtr) + { + *valInt = retValuePtr->Get(); + } + } + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalRetrievingVisualPropertyString(void *view, int visualIndex, int visualPropertyIndex, char** valString) + { + Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; + + if (!pControl) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + if (!valString) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "valString is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + // Copy inputed initialized string. + // Note : C# side inputed string reference count become reduced. + // So, If we want to keep life when we fail to get result, + // We should re-convert by SWIG_csharp_string_callback. + std::string temp = (*valString == nullptr) ? "" : *valString; + + Dali::Toolkit::Internal::Control& internalControl = Dali::Toolkit::Internal::GetImplementation(*pControl); + Dali::Toolkit::Visual::Base visualBase = Dali::Toolkit::DevelControl::GetVisual(internalControl, visualIndex); + if(visualBase) + { + Dali::Property::Map tempMap; + visualBase.CreatePropertyMap(tempMap); + Dali::Property::Value* retValuePtr = tempMap.Find(visualPropertyIndex); + if(retValuePtr) + { + //typemap in + temp = retValuePtr->Get(); + } + } + + //Typemap argout in c++ file. + //This will convert c++ string to c# string + *valString = SWIG_csharp_string_callback(temp.c_str()); + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalRetrievingVisualPropertyVector4(void *view, int visualIndex, int visualPropertyIndex, void *vector4) + { + Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; + Dali::Vector4 *pVector4 = (Dali::Vector4 *)vector4; + + if (!pControl) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + if (!pVector4) + { + SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector4 is null!"); + return (int)InternalPropertyReturnType::ERROR_UNKNOWN; + } + + try + { + Dali::Toolkit::Internal::Control& internalControl = Dali::Toolkit::Internal::GetImplementation(*pControl); + Dali::Toolkit::Visual::Base visualBase = Dali::Toolkit::DevelControl::GetVisual(internalControl, visualIndex); + if(visualBase) + { + Dali::Property::Map tempMap; + visualBase.CreatePropertyMap(tempMap); + Dali::Property::Value* retValuePtr = tempMap.Find(visualPropertyIndex); + if(retValuePtr) + { + *pVector4 = retValuePtr->Get(); + } + } + } + CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); + + return (int)InternalPropertyReturnType::NO_ERROR; + } +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/keyboard-focus-manager-wrap.cpp b/dali-csharp-binder/dali-toolkit/keyboard-focus-manager-wrap.cpp new file mode 100755 index 00000000..e87fc98b --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/keyboard-focus-manager-wrap.cpp @@ -0,0 +1,587 @@ +/* + * 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include + +SWIGINTERN bool Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Empty(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > const *self){ + return self->Empty(); + } +SWIGINTERN std::size_t Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__GetConnectionCount(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > const *self){ + return self->GetConnectionCount(); + } +SWIGINTERN void Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Connect(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *self,Dali::Actor (*func)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)){ + return self->Connect( func ); + } +SWIGINTERN void Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Disconnect(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *self,Dali::Actor (*func)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)){ + self->Disconnect( func ); + } +SWIGINTERN Dali::Actor Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Emit(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *self,Dali::Actor arg1,Dali::Actor arg2,Dali::Toolkit::Control::KeyboardFocus::Direction arg3){ + return self->Emit( arg1, arg2, arg3 ); + } + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_KeyboardFocusManager() { + void * jresult; + Dali::Toolkit::KeyboardFocusManager *result = 0 ; + + { + try { + result = (Dali::Toolkit::KeyboardFocusManager *)new Dali::Toolkit::KeyboardFocusManager(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_KeyboardFocusManager(void * jarg1) { + Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; + + arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_Get() { + void * jresult; + Dali::Toolkit::KeyboardFocusManager result; + + { + try { + result = Dali::Toolkit::KeyboardFocusManager::Get(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::KeyboardFocusManager((const Dali::Toolkit::KeyboardFocusManager &)result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_SetCurrentFocusActor(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; + Dali::Actor arg2; + Dali::Actor *argp2 ; + bool result; + + arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)(arg1)->SetCurrentFocusActor(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_GetCurrentFocusActor(void * jarg1) { + void * jresult ; + Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; + Dali::Actor result; + + arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; + { + try { + result = (arg1)->GetCurrentFocusActor(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_MoveFocus(void * jarg1, int jarg2) { + unsigned int jresult ; + Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; + Dali::Toolkit::Control::KeyboardFocus::Direction arg2; + bool result; + + arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; + arg2 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg2; + { + try { + result = (bool)(arg1)->MoveFocus(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_ClearFocus(void * jarg1) { + Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; + + arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; + { + try { + (arg1)->ClearFocus(); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_SetFocusGroupLoop(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0; + bool arg2; + + arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; + arg2 = jarg2 ? true : false; + { + try { + (arg1)->SetFocusGroupLoop(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_GetFocusGroupLoop(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; + { + try { + result = (bool)((Dali::Toolkit::KeyboardFocusManager const *)arg1)->GetFocusGroupLoop(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_SetAsFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) { + Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; + Dali::Actor arg2 ; + bool arg3 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + arg3 = jarg3 ? true : false; + { + try { + (arg1)->SetAsFocusGroup(arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_IsFocusGroup(void * jarg1, void * jarg2) { + unsigned int jresult ; + Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + bool result; + + arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (bool)((Dali::Toolkit::KeyboardFocusManager const *)arg1)->IsFocusGroup(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_GetFocusGroup(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + Dali::Actor result; + + arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg2 = *argp2; + { + try { + result = (arg1)->GetFocusGroup(arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) { + Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; + Dali::Actor arg2 ; + Dali::Actor *argp2 ; + + arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return ; + } + arg2 = *argp2; + { + try { + (arg1)->SetFocusIndicatorActor(arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_GetFocusIndicatorActor(void * jarg1) { + void * jresult ; + Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; + Dali::Actor result; + + arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; + { + try { + result = (arg1)->GetFocusIndicatorActor(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_MoveFocusBackward(void * jarg1) { + Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; + + arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; + { + try { + (arg1)->MoveFocusBackward(); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_EnableFocusIndicator(void * manager, bool enable) { + if (!manager) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0); + return ; + } + { + try { + Dali::Toolkit::DevelKeyboardFocusManager::EnableFocusIndicator(*(Dali::Toolkit::KeyboardFocusManager *)manager, enable); + } CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT bool SWIGSTDCALL CSharp_KeyboardFocusManager_IsFocusIndicatorEnabled(void * manager) { + bool result; + if (!manager) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0); + return 0; + } + { + try { + result = Dali::Toolkit::DevelKeyboardFocusManager::IsFocusIndicatorEnabled(*(Dali::Toolkit::KeyboardFocusManager *)manager); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_PreFocusChangeSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; + Dali::Toolkit::KeyboardFocusManager::PreFocusChangeSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; + { + try { + result = (Dali::Toolkit::KeyboardFocusManager::PreFocusChangeSignalType *) &(arg1)->PreFocusChangeSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_FocusChangedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; + Dali::Toolkit::KeyboardFocusManager::FocusChangedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; + { + try { + result = (Dali::Toolkit::KeyboardFocusManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_FocusGroupChangedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; + Dali::Toolkit::KeyboardFocusManager::FocusGroupChangedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; + { + try { + result = (Dali::Toolkit::KeyboardFocusManager::FocusGroupChangedSignalType *) &(arg1)->FocusGroupChangedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +GENERATE_SIGNAL(Dali::Toolkit::KeyboardFocusManager*, void(*)(Dali::Actor), KeyboardFocusManager, FocusedActorEnterKeySignal) +// CSharp_KeyboardFocusManager_FocusedActorEnterKeySignal_Connect +// CSharp_KeyboardFocusManager_FocusedActorEnterKeySignal_Disconnect + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Empty((Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1; + { + try { + result = Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__GetConnectionCount((Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + +typedef Dali::Actor* (SWIGSTDCALL* SWIG_CallbackKbPreFocusChange)(Dali::Actor *, Dali::Actor *, int); +SWIG_CallbackKbPreFocusChange swig_callbackOnKbPreFocusChange; + +Dali::Actor OnKbPreFocusChangeCallback(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) +{ + Dali::Actor *actorp; + Dali::Actor actor; + Dali::Actor *CurrentP = NULL; + Dali::Actor *ProposedP = NULL; + + if (current) + { + CurrentP = (Dali::Actor *)¤t; + } + + if (proposed) + { + ProposedP = (Dali::Actor *)&proposed; + } + + actorp = (Dali::Actor *)swig_callbackOnKbPreFocusChange(CurrentP, ProposedP, direction); + if (actorp) + { + actor = *actorp; + } + + return actor; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Connect(void * jarg1, SWIG_CallbackKbPreFocusChange callbackOnKbPreFocusChange) { + + swig_callbackOnKbPreFocusChange = callbackOnKbPreFocusChange; + + Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ; + Dali::Actor (*arg2)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)) 0 ; + + arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1; + arg2 = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction))OnKbPreFocusChangeCallback; + + { + try { + Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Disconnect(void * jarg1, SWIG_CallbackKbPreFocusChange callbackOnKbPreFocusChange) { + + swig_callbackOnKbPreFocusChange = callbackOnKbPreFocusChange; + + Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ; + Dali::Actor (*arg2)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)) 0 ; + + arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1; + arg2 = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction))OnKbPreFocusChangeCallback; + { + try { + Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Emit(void * jarg1, void * jarg2, void * jarg3, int jarg4) { + void * jresult ; + Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ; + Dali::Actor arg2 ; + Dali::Actor arg3 ; + Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ; + Dali::Actor *argp2 ; + Dali::Actor *argp3 ; + Dali::Actor result; + + arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1; + argp2 = (Dali::Actor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg2 = *argp2; + argp3 = (Dali::Actor *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); + return 0; + } + arg3 = *argp3; + arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4; + { + try { + result = Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Emit(arg1,arg2,arg3,arg4); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_GetNearestFocusableActor(void * jarg1, void * jarg2, Dali::Toolkit::Control::KeyboardFocus::Direction direction) { + void * jresult; + Dali::Actor *argp1 = (Dali::Actor *)jarg1; + Dali::Actor *argp2 = (Dali::Actor *)jarg2; + Dali::Actor rootActor; + Dali::Actor currentFocusedActor; + if (argp1) { + rootActor = *argp1; + } + if (argp2) { + currentFocusedActor = *argp2; + } + Dali::Actor result; + { + try { + result = Dali::Toolkit::FocusFinder::GetNearestFocusableActor(rootActor, currentFocusedActor, direction); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Actor((const Dali::Actor &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_KeyboardPreFocusChangeSignal() { + void * jresult ; + Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *result = 0 ; + + { + try { + result = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)new Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_KeyboardPreFocusChangeSignal(void * jarg1) { + Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ; + + arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_KeyboardFocusManager_SWIGUpcast(Dali::Toolkit::KeyboardFocusManager *jarg1) { + return (Dali::BaseHandle *)jarg1; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/scale-transition-wrap.cpp b/dali-csharp-binder/dali-toolkit/scale-transition-wrap.cpp new file mode 100755 index 00000000..d3e6816f --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/scale-transition-wrap.cpp @@ -0,0 +1,220 @@ +/* + * Copyright (c) 2021 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_ScaleTransition() + { + void *jresult; + Dali::Toolkit::ScaleTransition *result = 0; + + { + try + { + result = (Dali::Toolkit::ScaleTransition *)new Dali::Toolkit::ScaleTransition(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_ScaleTransition_New_1(void *nuiControl, float scale, void *nuiTimePeriod) + { + void *jresult; + Dali::Toolkit::Control *control = (Dali::Toolkit::Control *)nuiControl; + Dali::TimePeriod *timePeriod = (Dali::TimePeriod *)nuiTimePeriod; + + Dali::Toolkit::ScaleTransition result; + + if (!control) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0); + return 0; + } + { + try + { + result = Dali::Toolkit::ScaleTransition::New(*control, scale, *timePeriod); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ScaleTransition((const Dali::Toolkit::ScaleTransition &)result); + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_ScaleTransition_New_2(void *nuiControl, void *nuiScale, void *nuiTimePeriod) + { + void *jresult; + Dali::Toolkit::Control *control = (Dali::Toolkit::Control *)nuiControl; + Dali::Vector2 *scale = (Dali::Vector2 *)nuiScale; + Dali::TimePeriod *timePeriod = (Dali::TimePeriod *)nuiTimePeriod; + + Dali::Toolkit::ScaleTransition result; + + if (!control) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0); + return 0; + } + if (!scale) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try + { + result = Dali::Toolkit::ScaleTransition::New(*control, *scale, *timePeriod); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::ScaleTransition((const Dali::Toolkit::ScaleTransition &)result); + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScaleTransition(void *nuiScaleTransition) + { + Dali::Toolkit::ScaleTransition *scale = (Dali::Toolkit::ScaleTransition *)nuiScaleTransition; + + if (!scale) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0); + return; + } + { + try + { + delete scale; + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_ScaleTransition_Set(void *nuiScaleTransition) + { + Dali::Toolkit::ScaleTransition *newScaleTransition = 0; + Dali::Toolkit::ScaleTransition *scale = (Dali::Toolkit::ScaleTransition *)nuiScaleTransition; + + if (!scale) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScaleTransition const & type is null", 0); + return 0; + } + { + try + { + newScaleTransition = (Dali::Toolkit::ScaleTransition *)new Dali::Toolkit::ScaleTransition((Dali::Toolkit::ScaleTransition const &)*scale); + } + CALL_CATCH_EXCEPTION(0); + } + void *result; + result = (void *)newScaleTransition; + return result; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_ScaleTransition_Assign(void *nuiDestination, void *nuiSource) + { + void *jresult; + Dali::Toolkit::ScaleTransition *destination = (Dali::Toolkit::ScaleTransition *)nuiDestination; + Dali::Toolkit::ScaleTransition *source = (Dali::Toolkit::ScaleTransition *)nuiSource; + Dali::Toolkit::ScaleTransition *result = 0; + + if (!destination) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScaleTransition const & type is null", 0); + return 0; + } + if (!source) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScaleTransition const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Toolkit::ScaleTransition *)&(destination)->operator=((Dali::Toolkit::ScaleTransition const &)*source); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScaleTransition_SetScaleFactor(void *nuiScaleTransition, void *nuiScaleFactor) + { + Dali::Toolkit::ScaleTransition *scale = (Dali::Toolkit::ScaleTransition *)nuiScaleTransition; + Dali::Vector2 *scaleFactor = (Dali::Vector2 *)nuiScaleFactor; + + if (!scale) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScaleTransition const & type is null", 0); + return; + } + if (!scaleFactor) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return; + } + { + try + { + (scale)->SetScaleFactor((Dali::Vector2 const &)*scaleFactor); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_ScaleTransition_GetScaleFactor(void *nuiScaleTransition) + { + void *jresult; + Dali::Toolkit::ScaleTransition *scale = (Dali::Toolkit::ScaleTransition *)nuiScaleTransition; + Dali::Vector2 result; + + if (!scale) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScaleTransition const & type is null", 0); + return 0; + } + { + try + { + result = (scale)->GetScaleFactor(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; + } + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/slide-transition-wrap.cpp b/dali-csharp-binder/dali-toolkit/slide-transition-wrap.cpp new file mode 100755 index 00000000..d0bd7324 --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/slide-transition-wrap.cpp @@ -0,0 +1,228 @@ +/* + * Copyright (c) 2021 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_SlideTransition() + { + void *jresult; + Dali::Toolkit::SlideTransition *result = 0; + + { + try + { + result = (Dali::Toolkit::SlideTransition *)new Dali::Toolkit::SlideTransition(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SlideTransition_New(void *nuiControl, void *nuiDirection, void *nuiTimePeriod) + { + void *jresult; + Dali::Toolkit::Control *control = (Dali::Toolkit::Control *)nuiControl; + Dali::Vector2 *direction = (Dali::Vector2 *)nuiDirection; + Dali::TimePeriod *timePeriod = (Dali::TimePeriod *)nuiTimePeriod; + + Dali::Toolkit::SlideTransition result; + + if (!control) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0); + return 0; + } + if (!direction) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return 0; + } + { + try + { + result = Dali::Toolkit::SlideTransition::New(*control, *direction, *timePeriod); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::SlideTransition((const Dali::Toolkit::SlideTransition &)result); + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlideTransition(void *nuiSlideTransition) + { + Dali::Toolkit::SlideTransition *slide = (Dali::Toolkit::SlideTransition *)0; + + slide = (Dali::Toolkit::SlideTransition *)nuiSlideTransition; + + if (!slide) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0); + return; + } + { + try + { + delete slide; + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_SlideTransition_Set(void *nuiSlideTransition) + { + Dali::Toolkit::SlideTransition *newSlideTransition = 0; + Dali::Toolkit::SlideTransition *slide = (Dali::Toolkit::SlideTransition *)nuiSlideTransition; + + if (!slide) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::SlideTransition const & type is null", 0); + return 0; + } + { + try + { + newSlideTransition = (Dali::Toolkit::SlideTransition *)new Dali::Toolkit::SlideTransition((Dali::Toolkit::SlideTransition const &)*slide); + } + CALL_CATCH_EXCEPTION(0); + } + void *result; + result = (void *)newSlideTransition; + return result; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SlideTransition_Assign(void *nuiDestination, void *nuiSource) + { + void *jresult; + Dali::Toolkit::SlideTransition *destination = (Dali::Toolkit::SlideTransition *)0; + Dali::Toolkit::SlideTransition *source = 0; + Dali::Toolkit::SlideTransition *result = 0; + + destination = (Dali::Toolkit::SlideTransition *)nuiDestination; + source = (Dali::Toolkit::SlideTransition *)nuiSource; + + if (!destination) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::SlideTransition const & type is null", 0); + return 0; + } + if (!source) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::SlideTransition const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Toolkit::SlideTransition *)&(destination)->operator=((Dali::Toolkit::SlideTransition const &)*source); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlideTransition_SetDirection(void *nuiSlideTransition, void *nuiDirection) + { + Dali::Toolkit::SlideTransition *slide = (Dali::Toolkit::SlideTransition *)nuiSlideTransition; + Dali::Vector2 *direction = (Dali::Vector2 *)nuiDirection; + + if (!slide) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::SlideTransition const & type is null", 0); + return; + } + if (!direction) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); + return; + } + { + try + { + (slide)->SetDirection((Dali::Vector2 const &)*direction); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SlideTransition_GetDirection(void *nuiSlideTransition) + { + void *jresult; + Dali::Toolkit::SlideTransition *slide = (Dali::Toolkit::SlideTransition *)nuiSlideTransition; + Dali::Vector2 result; + + if (!slide) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::SlideTransition const & type is null", 0); + return 0; + } + { + try + { + result = (slide)->GetDirection(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Vector2((const Dali::Vector2 &)result); + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SlideTransitionDirectionTop_get() + { + Dali::Vector2 *result = (Dali::Vector2 *)&Dali::Toolkit::SlideTransitionDirection::TOP; + + return (void *)result; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SlideTransitionDirectionBottom_get() + { + Dali::Vector2 *result = (Dali::Vector2 *)&Dali::Toolkit::SlideTransitionDirection::BOTTOM; + + return (void *)result; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SlideTransitionDirectionRight_get() + { + Dali::Vector2 *result = (Dali::Vector2 *)&Dali::Toolkit::SlideTransitionDirection::RIGHT; + + return (void *)result; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SlideTransitionDirectionLeft_get() + { + Dali::Vector2 *result = (Dali::Vector2 *)&Dali::Toolkit::SlideTransitionDirection::LEFT; + + return (void *)result; + } + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/style-manager-wrap.cpp b/dali-csharp-binder/dali-toolkit/style-manager-wrap.cpp new file mode 100644 index 00000000..65d848fb --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/style-manager-wrap.cpp @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2021 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +/* Callback for returning strings to C# without leaking memory */ +typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char*); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetBrokenImageUrl(void * nuiStyleManager, unsigned int brokenType, char * nuiUrl) { + Dali::Toolkit::StyleManager *styleManager = (Dali::Toolkit::StyleManager *) 0 ; + std::string *url = 0 ; + + if(!nuiUrl) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return; + } + + std::string url_str(nuiUrl); + url = &url_str; + styleManager = (Dali::Toolkit::StyleManager *)nuiStyleManager; + { + try { + Dali::Toolkit::DevelStyleManager::SetBrokenImageUrl(*styleManager,Dali::Toolkit::DevelStyleManager::BrokenImageType(brokenType),(std::string const &)*url); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StyleManager_GetBrokenImageUrl(void * nuiStyleManager, unsigned int brokenType) { + char * jresult ; + Dali::Toolkit::StyleManager *styleManager = (Dali::Toolkit::StyleManager *) 0 ; + std::string result; + + styleManager = (Dali::Toolkit::StyleManager *)nuiStyleManager; + { + try { + result = Dali::Toolkit::DevelStyleManager::GetBrokenImageUrl(*styleManager,Dali::Toolkit::DevelStyleManager::BrokenImageType(brokenType)); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = SWIG_csharp_string_callback((&result)->c_str()); + return jresult; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/text-character-sequence-wrap.cpp b/dali-csharp-binder/dali-toolkit/text-character-sequence-wrap.cpp new file mode 100644 index 00000000..9770be7f --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/text-character-sequence-wrap.cpp @@ -0,0 +1,127 @@ +/* + * Copyright (c) 2022 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include + +/* Callback for returning strings to C# without leaking memory */ +typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +#ifdef __cplusplus +extern "C" { +#endif + +using namespace Dali::Toolkit::Text; + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_delete_CharacterSequence(void *refCharacterSequence) { + CharacterSequence *characterSequencePtr = (CharacterSequence *)0; + characterSequencePtr = (CharacterSequence *)refCharacterSequence; + + { + try { + delete characterSequencePtr; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL +CSharp_Dali_CharacterSequence_GetCharacters(void *refCharacterSequence) { + + CharacterSequence *characterSequencePtr; + void *result = nullptr; + + characterSequencePtr = (CharacterSequence *)refCharacterSequence; + if (!characterSequencePtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null CharacterSequence", 0); + return 0; + } + + { + try { + result = new Dali::Vector( + (const Dali::Vector &)(characterSequencePtr + ->GetCharacters())); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT unsigned int SWIGSTDCALL +CSharp_Dali_CharacterSequence_GetNumberOfCharacters( + void *refCharacterSequence) { + + CharacterSequence *characterSequencePtr; + unsigned int result = 0; + + characterSequencePtr = (CharacterSequence *)refCharacterSequence; + if (!characterSequencePtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null CharacterSequence", 0); + return 0; + } + + { + try { + result = characterSequencePtr->GetNumberOfCharacters(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT char *SWIGSTDCALL +CSharp_Dali_CharacterSequence_ToString(void *refCharacterSequence) { + + CharacterSequence *characterSequencePtr; + std::string result; + + characterSequencePtr = (CharacterSequence *)refCharacterSequence; + if (!characterSequencePtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null CharacterSequence", 0); + return 0; + } + + { + try { + result = characterSequencePtr->ToString(); + } + CALL_CATCH_EXCEPTION(0); + } + + char *csResult = SWIG_csharp_string_callback(result.c_str()); + return csResult; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/text-editor-wrap.cpp b/dali-csharp-binder/dali-toolkit/text-editor-wrap.cpp new file mode 100755 index 00000000..5bf27c54 --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/text-editor-wrap.cpp @@ -0,0 +1,1480 @@ +/* + * Copyright (c) 2020 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include + +// INTERNAL INCLUDES +#include + +/* Callback for returning strings to C# without leaking memory */ +typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){ +return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){ + self->Emit( arg ); +} + +SWIGINTERN bool Dali_Signal_void_TextEditor_Scroll_Type__Empty(Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_void_TextEditor_Scroll_Type__GetConnectionCount(Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > const *self){ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_void_TextEditor_Scroll_Type__Connect(Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *self,void (*func)(Dali::Toolkit::TextEditor,Dali::Toolkit::TextEditor::Scroll::Type)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_void_TextEditor_Scroll_Type__Disconnect(Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *self,void (*func)(Dali::Toolkit::TextEditor,Dali::Toolkit::TextEditor::Scroll::Type)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_void_TextEditor_Scroll_Type__Emit(Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *self,Dali::Toolkit::TextEditor arg1,Dali::Toolkit::TextEditor::Scroll::Type arg2){ + self->Emit( arg1, arg2 ); +} + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +/*TextEditor Property binding*/ +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::RENDERING_BACKEND; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::TEXT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_VERTICAL_ALIGNMENT_get() { + + return (int)Dali::Toolkit::DevelTextEditor::Property::VERTICAL_ALIGNMENT; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RELATIVE_LINE_SIZE_get() { + + return (int)Dali::Toolkit::DevelTextEditor::Property::RELATIVE_LINE_SIZE; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::SHADOW; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_SMOOTH_SCROLL_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::SMOOTH_SCROLL; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_SMOOTH_SCROLL_DURATION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::SMOOTH_SCROLL_DURATION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_ENABLE_SCROLL_BAR_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_SCROLL_BAR; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_SCROLL_BAR_SHOW_DURATION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_BAR_SHOW_DURATION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_SCROLL_BAR_FADE_DURATION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_BAR_FADE_DURATION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_PIXEL_SIZE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::PIXEL_SIZE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_LINE_COUNT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::LINE_COUNT; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_PLACEHOLDER_TEXT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::PLACEHOLDER_TEXT; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_PLACEHOLDER_TEXT_COLOR_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::PLACEHOLDER_TEXT_COLOR; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_ENABLE_SELECTION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_SELECTION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_PLACEHOLDER_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextEditor::Property::PLACEHOLDER; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTED_TEXT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::SELECTED_TEXT; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTED_TEXT_START_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::SELECTED_TEXT_START; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTED_TEXT_END_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::SELECTED_TEXT_END; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_SCROLL_POSITION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::HORIZONTAL_SCROLL_POSITION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_VERTICAL_SCROLL_POSITION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::VERTICAL_SCROLL_POSITION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_POSITION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::PRIMARY_CURSOR_POSITION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_COLOR_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::GRAB_HANDLE_COLOR; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FILTER_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::INPUT_FILTER; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_POPUP_STYLE_get() +{ + return (int)Dali::Toolkit::DevelTextEditor::Property::SELECTION_POPUP_STYLE; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditor_ScrollBy(void * jarg1, void * jarg2) { + Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0; + Dali::Vector2 *arg2 = 0 ; + + arg1 = (Dali::Toolkit::TextEditor *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 type is null", 0); + return ; + } + + { + try { + Dali::Toolkit::DevelTextEditor::ScrollBy( *arg1 , *arg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_EDITING_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::ENABLE_EDITING; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_SIZE_SCALE_get() +{ + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::FONT_SIZE_SCALE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_FONT_SIZE_SCALE_get() +{ + return (int)Dali::Toolkit::DevelTextEditor::Property::ENABLE_FONT_SIZE_SCALE; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_GRAB_HANDLE_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::ENABLE_GRAB_HANDLE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_GRAB_HANDLE_POPUP_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::ENABLE_GRAB_HANDLE_POPUP; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_METHOD_SETTINGS_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::INPUT_METHOD_SETTINGS; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() { + void * jresult ; + Dali::Toolkit::TextEditor::Property *result = 0 ; + + { + try { + result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) { + Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ; + + arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() { + void * jresult ; + Dali::Toolkit::TextEditor::InputStyle *result = 0 ; + + { + try { + result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) { + Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ; + + arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() { + void * jresult ; + Dali::Toolkit::TextEditor result; + + { + try { + result = Dali::Toolkit::TextEditor::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New_With_Style(bool hasStyle) { + void * jresult ; + Dali::Toolkit::TextEditor result; + + { + try { + if (hasStyle) { + result = Dali::Toolkit::TextEditor::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS); + } else { + result = Dali::Toolkit::TextEditor::New(); + } + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() { + void * jresult ; + Dali::Toolkit::TextEditor *result = 0 ; + + { + try { + result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::TextEditor *arg1 = 0 ; + Dali::Toolkit::TextEditor *result = 0 ; + + arg1 = (Dali::Toolkit::TextEditor *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ; + Dali::Toolkit::TextEditor *arg2 = 0 ; + Dali::Toolkit::TextEditor *result = 0 ; + + arg1 = (Dali::Toolkit::TextEditor *)jarg1; + arg2 = (Dali::Toolkit::TextEditor *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) { + Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ; + + arg1 = (Dali::Toolkit::TextEditor *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::TextEditor 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::TextEditor::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ; + Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::TextEditor *)jarg1; + { + try { + result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ; + Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::TextEditor *)jarg1; + { + try { + result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_AnchorClickedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ; + Dali::Toolkit::DevelTextEditor::AnchorClickedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::TextEditor *)jarg1; + { + try { + result = (Dali::Toolkit::DevelTextEditor::AnchorClickedSignalType *)&Dali::Toolkit::DevelTextEditor::AnchorClickedSignal(*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputFilteredSignal(void * pTextEditor) { + void * jresult ; + Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0 ; + Dali::Toolkit::DevelTextEditor::InputFilteredSignalType *result = 0 ; + + textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; + { + try { + result = (Dali::Toolkit::DevelTextEditor::InputFilteredSignalType *)&Dali::Toolkit::DevelTextEditor::InputFilteredSignal(*textEditor); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditor_SelectWholeText(void * jarg1) { + Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0; + + arg1 = (Dali::Toolkit::TextEditor *)jarg1; + { + try { + Dali::Toolkit::DevelTextEditor::SelectWholeText( *arg1 ); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditor_SelectText(void * pTextEditor, unsigned int start, unsigned int end) { + Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0; + + textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; + { + try { + Dali::Toolkit::DevelTextEditor::SelectText( *textEditor, start, end ); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditor_SelectNone(void * jarg1) { + Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0; + + arg1 = (Dali::Toolkit::TextEditor *)jarg1; + { + try { + Dali::Toolkit::DevelTextEditor::SelectNone( *arg1 ); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_GetTextSize(void * pTextEditor, unsigned int start, unsigned int end) +{ + Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0; + void* sizeList; + + textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; + { + try { + sizeList = new Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > + ((const Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > &)(Dali::Toolkit::DevelTextEditor::GetTextSize( *textEditor, start, end ))); + } + CALL_CATCH_EXCEPTION(0); + } + + return sizeList; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_GetTextPosition(void * pTextEditor, unsigned int start, unsigned int end) +{ + Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0; + void* sizeList; + + textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; + { + try { + sizeList = new Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > + ((const Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > &)(Dali::Toolkit::DevelTextEditor::GetTextPosition( *textEditor, start, end ))); + } + CALL_CATCH_EXCEPTION(0); + } + + return sizeList; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_TextGeometry_TextEditor_GetTextBoundingRectangle(void * pTextEditor, uint32_t startIndex, uint32_t endIndex) +{ + Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0; + void* boundingRect; + + textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; + { + try { + boundingRect = new Dali::Rect<> + ((const Dali::Rect<> &)(Dali::Toolkit::DevelTextEditor::GetTextBoundingRectangle( *textEditor, startIndex, endIndex))); + } + CALL_CATCH_EXCEPTION(0); + } + + return boundingRect; +} + +SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_TextEditor_CopyText(void *pTextEditor) +{ + char *csCopiedText; + Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *)0; + std::string copiedText; + + textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; + { + try { + copiedText = Dali::Toolkit::DevelTextEditor::CopyText(*textEditor); + } + CALL_CATCH_EXCEPTION(0); + } + csCopiedText = SWIG_csharp_string_callback((&copiedText)->c_str()); + return csCopiedText; +} + +SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_TextEditor_CutText(void *pTextEditor) +{ + char *csCutText; + Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *)0; + std::string cutText; + + textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; + { + try { + cutText = Dali::Toolkit::DevelTextEditor::CutText(*textEditor); + } + CALL_CATCH_EXCEPTION(0); + } + csCutText = SWIG_csharp_string_callback((&cutText)->c_str()); + return csCutText; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditor_PasteText(void *pTextEditor) +{ + Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *)0; + + textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; + { + try { + Dali::Toolkit::DevelTextEditor::PasteText(*textEditor); + } + CALL_CATCH_EXCEPTION(); + } +} + +/*TextEditorSignal*/ +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ; + void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ; + void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ; + Dali::Toolkit::TextEditor arg2 ; + Dali::Toolkit::TextEditor *argp2 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1; + argp2 = (Dali::Toolkit::TextEditor *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0); + return ; + } + arg2 = *argp2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() { + void * jresult ; + Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) { + Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +/*ScrollStateChangedSignal*/ +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_ScrollStateChangedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::TextEditor *arg1 = 0 ; + Dali::Toolkit::TextEditor::ScrollStateChangedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::TextEditor *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::TextEditor::ScrollStateChangedSignalType *) &arg1->ScrollStateChangedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollStateChangedSignal_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *)jarg1; + { + try { + result = (bool)Dali_Signal_void_TextEditor_Scroll_Type__Empty((Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollStateChangedSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *)jarg1; + { + try { + result = Dali_Signal_void_TextEditor_Scroll_Type__GetConnectionCount((Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollStateChangedSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *) 0 ; + void (*arg2)(Dali::Toolkit::TextEditor,Dali::Toolkit::TextEditor::Scroll::Type) = (void (*)(Dali::Toolkit::TextEditor,Dali::Toolkit::TextEditor::Scroll::Type)) 0 ; + + arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::TextEditor,Dali::Toolkit::TextEditor::Scroll::Type))jarg2; + { + try { + Dali_Signal_void_TextEditor_Scroll_Type__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollStateChangedSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *) 0 ; + void (*arg2)(Dali::Toolkit::TextEditor,Dali::Toolkit::TextEditor::Scroll::Type) = (void (*)(Dali::Toolkit::TextEditor,Dali::Toolkit::TextEditor::Scroll::Type)) 0 ; + + arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::TextEditor,Dali::Toolkit::TextEditor::Scroll::Type))jarg2; + { + try { + Dali_Signal_void_TextEditor_Scroll_Type__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollStateChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) { + Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *) 0 ; + Dali::Toolkit::TextEditor arg2 ; + Dali::Toolkit::TextEditor::Scroll::Type arg3; + Dali::Toolkit::TextEditor *argp2 ; + + arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *)jarg1; + argp2 = (Dali::Toolkit::TextEditor *)jarg2; + arg3 = (Dali::Toolkit::TextEditor::Scroll::Type)jarg3; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0); + return ; + } + arg2 = *argp2; + { + try { + Dali_Signal_void_TextEditor_Scroll_Type__Emit(arg1,arg2,arg3); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollStateChangedSignal() { + void * jresult ; + Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *result = 0 ; + + { + try { + result = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *)new Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollStateChangedSignal(void * jarg1) { + Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *) 0 ; + + arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_ENABLE_SHIFT_SELECTION_get() +{ + return (int)Dali::Toolkit::DevelTextEditor::Property::ENABLE_SHIFT_SELECTION; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_MATCH_SYSTEM_LANGUAGE_DIRECTION_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_MAX_LENGTH_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextEditor::Property::MAX_LENGTH; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_GetInputMethodContext(void * jarg1) { + void * jresult ; + Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ; + Dali::InputMethodContext result; + + arg1 = (Dali::Toolkit::TextEditor *)jarg1; + { + try { + result = Dali::Toolkit::DevelTextEditor::GetInputMethodContext(*arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::InputMethodContext((const Dali::InputMethodContext &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_CursorPositionChangedSignal(void * pTextEditor) { + void * jresult ; + Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0 ; + Dali::Toolkit::DevelTextEditor::CursorPositionChangedSignalType *result = 0 ; + + textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; + { + try { + result = (Dali::Toolkit::DevelTextEditor::CursorPositionChangedSignalType *)&Dali::Toolkit::DevelTextEditor::CursorPositionChangedSignal(*textEditor); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_MaxLengthReachedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ; + Dali::Toolkit::DevelTextEditor::MaxLengthReachedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::TextEditor *)jarg1; + { + try { + result = (Dali::Toolkit::DevelTextEditor::MaxLengthReachedSignalType *)&Dali::Toolkit::DevelTextEditor::MaxLengthReachedSignal(*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_SelectionClearedSignal(void * pTextEditor) { + void * jresult ; + Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0 ; + Dali::Toolkit::DevelTextEditor::SelectionClearedSignalType *result = 0 ; + + textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; + { + try { + result = (Dali::Toolkit::DevelTextEditor::SelectionClearedSignalType *)&Dali::Toolkit::DevelTextEditor::SelectionClearedSignal(*textEditor); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_SelectionStartedSignal(void * pTextEditor) { + void * jresult ; + Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0 ; + Dali::Toolkit::DevelTextEditor::SelectionStartedSignalType *result = 0 ; + + textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; + { + try { + result = (Dali::Toolkit::DevelTextEditor::SelectionStartedSignalType *)&Dali::Toolkit::DevelTextEditor::SelectionStartedSignal(*textEditor); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_SelectionChangedSignal(void * pTextEditor) { + void * jresult ; + Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0 ; + Dali::Toolkit::DevelTextEditor::SelectionChangedSignalType *result = 0 ; + + textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; + { + try { + result = (Dali::Toolkit::DevelTextEditor::SelectionChangedSignalType *)&Dali::Toolkit::DevelTextEditor::SelectionChangedSignal(*textEditor); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/dali-toolkit/text-field-wrap.cpp b/dali-csharp-binder/dali-toolkit/text-field-wrap.cpp new file mode 100755 index 00000000..a760858d --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/text-field-wrap.cpp @@ -0,0 +1,1255 @@ +/* + * Copyright (c) 2020 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include + +// INTERNAL INCLUDES +#include + +/* Callback for returning strings to C# without leaking memory */ +typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){ +return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){ + self->Emit( arg ); +} + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +/*TextField property binding*/ +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextField::Property::RENDERING_BACKEND; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::TEXT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::UNDERLINE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::SHADOW; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::EMBOSS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::OUTLINE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_HIDDEN_INPUT_SETTINGS_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::HIDDEN_INPUT_SETTINGS; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_PIXEL_SIZE_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::PIXEL_SIZE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_ENABLE_SELECTION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::ENABLE_SELECTION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_ENABLE_GRAB_HANDLE_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelTextField::Property::ENABLE_GRAB_HANDLE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_ENABLE_GRAB_HANDLE_POPUP_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelTextField::Property::ENABLE_GRAB_HANDLE_POPUP; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_PLACEHOLDER_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_ELLIPSIS_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::TextField::Property::ELLIPSIS; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTED_TEXT_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextField::Property::SELECTED_TEXT; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTED_TEXT_START_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextField::Property::SELECTED_TEXT_START; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTED_TEXT_END_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextField::Property::SELECTED_TEXT_END; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_EDITING_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextField::Property::ENABLE_EDITING; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_SIZE_SCALE_get() +{ + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelTextField::Property::FONT_SIZE_SCALE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_FONT_SIZE_SCALE_get() +{ + return (int)Dali::Toolkit::DevelTextField::Property::ENABLE_FONT_SIZE_SCALE; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_POSITION_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextField::Property::PRIMARY_CURSOR_POSITION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_COLOR_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextField::Property::GRAB_HANDLE_COLOR; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FILTER_get() { + int jresult ; + int result; + + result = (int)Dali::Toolkit::DevelTextField::Property::INPUT_FILTER; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_POPUP_STYLE_get() +{ + return (int)Dali::Toolkit::DevelTextField::Property::SELECTION_POPUP_STYLE; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() { + void * jresult ; + Dali::Toolkit::TextField::Property *result = 0 ; + + { + try { + result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) { + Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ; + + arg1 = (Dali::Toolkit::TextField::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() { + void * jresult ; + Dali::Toolkit::TextField::InputStyle *result = 0 ; + + { + try { + result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) { + Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ; + + arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() { + void * jresult ; + Dali::Toolkit::TextField result; + + { + try { + result = Dali::Toolkit::TextField::New(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New_With_Style(bool hasStyle) { + void * jresult ; + Dali::Toolkit::TextField result; + + { + try { + if (hasStyle) { + result = Dali::Toolkit::TextField::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS); + } else { + result = Dali::Toolkit::TextField::New(); + } + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() { + void * jresult ; + Dali::Toolkit::TextField *result = 0 ; + + { + try { + result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) { + void * jresult ; + Dali::Toolkit::TextField *arg1 = 0 ; + Dali::Toolkit::TextField *result = 0 ; + + arg1 = (Dali::Toolkit::TextField *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ; + Dali::Toolkit::TextField *arg2 = 0 ; + Dali::Toolkit::TextField *result = 0 ; + + arg1 = (Dali::Toolkit::TextField *)jarg1; + arg2 = (Dali::Toolkit::TextField *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) { + Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ; + + arg1 = (Dali::Toolkit::TextField *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::Toolkit::TextField 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::TextField::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ; + Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::TextField *)jarg1; + { + try { + result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_CursorPositionChangedSignal(void * pTextField) { + void * jresult ; + Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0 ; + Dali::Toolkit::DevelTextField::CursorPositionChangedSignalType *result = 0 ; + + textField = (Dali::Toolkit::TextField *)pTextField; + { + try { + result = (Dali::Toolkit::DevelTextField::CursorPositionChangedSignalType *)&Dali::Toolkit::DevelTextField::CursorPositionChangedSignal(*textField); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ; + Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::TextField *)jarg1; + { + try { + result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ; + Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::TextField *)jarg1; + { + try { + result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_AnchorClickedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ; + Dali::Toolkit::DevelTextField::AnchorClickedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::TextField *)jarg1; + { + try { + result = (Dali::Toolkit::DevelTextField::AnchorClickedSignalType *)&Dali::Toolkit::DevelTextField::AnchorClickedSignal(*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputFilteredSignal(void * pTextField) { + void * jresult ; + Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0 ; + Dali::Toolkit::DevelTextField::InputFilteredSignalType *result = 0 ; + + textField = (Dali::Toolkit::TextField *)pTextField; + { + try { + result = (Dali::Toolkit::DevelTextField::InputFilteredSignalType *)&Dali::Toolkit::DevelTextField::InputFilteredSignal(*textField); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextField_SelectWholeText(void * jarg1) { + Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0; + + arg1 = (Dali::Toolkit::TextField *)jarg1; + { + try { + Dali::Toolkit::DevelTextField::SelectWholeText( *arg1 ); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextField_SelectText(void * pTextField, unsigned int start, unsigned int end) { + Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0; + + textField = (Dali::Toolkit::TextField *)pTextField; + { + try { + Dali::Toolkit::DevelTextField::SelectText( *textField, start, end ); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextField_SelectNone(void * jarg1) { + Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0; + + arg1 = (Dali::Toolkit::TextField *)jarg1; + { + try { + Dali::Toolkit::DevelTextField::SelectNone( *arg1 ); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_GetTextSize(void * pTextField, unsigned int start, unsigned int end) +{ + Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0; + void* sizeList; + + textField = (Dali::Toolkit::TextField *)pTextField; + { + try { + sizeList = new Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > + ((const Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > &)(Dali::Toolkit::DevelTextField::GetTextSize( *textField, start, end ))); + } + CALL_CATCH_EXCEPTION(0); + } + + return sizeList; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_GetTextPosition(void * pTextField, unsigned int start, unsigned int end) +{ + Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0; + void* sizeList; + + textField = (Dali::Toolkit::TextField *)pTextField; + { + try { + sizeList = new Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > + ((const Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > &)(Dali::Toolkit::DevelTextField::GetTextPosition( *textField, start, end ))); + } + CALL_CATCH_EXCEPTION(0); + } + + return sizeList; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_TextGeometry_TextField_GetTextBoundingRectangle(void * pTextField, uint32_t startIndex, uint32_t endIndex) +{ + Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0; + void* boundingRect; + + textField = (Dali::Toolkit::TextField *)pTextField; + { + try { + boundingRect = new Dali::Rect<> + ((const Dali::Rect<> &)(Dali::Toolkit::DevelTextField::GetTextBoundingRectangle( *textField, startIndex, endIndex))); + } + CALL_CATCH_EXCEPTION(0); + } + + return boundingRect; +} + +SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_TextField_CopyText(void *pTextField) +{ + char *csCopiedText; + Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *)0; + std::string copiedText; + + textField = (Dali::Toolkit::TextField *)pTextField; + { + try { + copiedText = Dali::Toolkit::DevelTextField::CopyText(*textField); + } + CALL_CATCH_EXCEPTION(0); + } + csCopiedText = SWIG_csharp_string_callback((&copiedText)->c_str()); + return csCopiedText; +} + +SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_TextField_CutText(void *pTextField) +{ + char *csCutText; + Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *)0; + std::string cutText; + + textField = (Dali::Toolkit::TextField *)pTextField; + { + try { + cutText = Dali::Toolkit::DevelTextField::CutText(*textField); + } + CALL_CATCH_EXCEPTION(0); + } + csCutText = SWIG_csharp_string_callback((&cutText)->c_str()); + return csCutText; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextField_PasteText(void *pTextField) +{ + Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *)0; + + textField = (Dali::Toolkit::TextField *)pTextField; + { + try { + Dali::Toolkit::DevelTextField::PasteText(*textField); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ; + void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::TextField))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ; + void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::TextField))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ; + Dali::Toolkit::TextField arg2 ; + Dali::Toolkit::TextField *argp2 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1; + argp2 = (Dali::Toolkit::TextField *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0); + return ; + } + arg2 = *argp2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() { + void * jresult ; + Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) { + Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_ENABLE_SHIFT_SELECTION_get() +{ + return (int)Dali::Toolkit::DevelTextField::Property::ENABLE_SHIFT_SELECTION; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_MATCH_SYSTEM_LANGUAGE_DIRECTION_get() { + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelTextField::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_GetInputMethodContext(void * jarg1) { + void * jresult ; + Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ; + Dali::InputMethodContext result; + + arg1 = (Dali::Toolkit::TextField *)jarg1; + { + try { + result = Dali::Toolkit::DevelTextField::GetInputMethodContext(*arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::InputMethodContext((const Dali::InputMethodContext &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_SelectionClearedSignal(void * pTextField) { + void * jresult ; + Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0 ; + Dali::Toolkit::DevelTextField::SelectionClearedSignalType *result = 0 ; + + textField = (Dali::Toolkit::TextField *)pTextField; + { + try { + result = (Dali::Toolkit::DevelTextField::SelectionClearedSignalType *)&Dali::Toolkit::DevelTextField::SelectionClearedSignal(*textField); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_SelectionStartedSignal(void * pTextField) { + void * jresult ; + Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0 ; + Dali::Toolkit::DevelTextField::SelectionStartedSignalType *result = 0 ; + + textField = (Dali::Toolkit::TextField *)pTextField; + { + try { + result = (Dali::Toolkit::DevelTextField::SelectionStartedSignalType *)&Dali::Toolkit::DevelTextField::SelectionStartedSignal(*textField); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_SelectionChangedSignal(void * pTextField) { + void * jresult ; + Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0 ; + Dali::Toolkit::DevelTextField::SelectionChangedSignalType *result = 0 ; + + textField = (Dali::Toolkit::TextField *)pTextField; + { + try { + result = (Dali::Toolkit::DevelTextField::SelectionChangedSignalType *)&Dali::Toolkit::DevelTextField::SelectionChangedSignal(*textField); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/dali-toolkit/text-geometry-wrap.cpp b/dali-csharp-binder/dali-toolkit/text-geometry-wrap.cpp new file mode 100644 index 00000000..ab361a92 --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/text-geometry-wrap.cpp @@ -0,0 +1,187 @@ +/* + * Copyright (c) 2021 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include +#include +#include +#include +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void * SWIGSTDCALL CSharp_TextGeometry_TextLabel_GetLineBoundingRectangle(void * pTextLabel, uint32_t lineIndex) +{ + Dali::Toolkit::TextLabel *textLabel = (Dali::Toolkit::TextLabel *) 0; + void* resultRect; + + textLabel = (Dali::Toolkit::TextLabel *)pTextLabel; + { + try { + resultRect = new Dali::Rect + ((const Dali::Rect &)(Dali::Toolkit::Text::TextGeometry::GetLineBoundingRectangle( *textLabel, lineIndex))); + } + CALL_CATCH_EXCEPTION(0); + } + + return resultRect; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_TextGeometry_TextField_GetLineBoundingRectangle(void * pTextField, uint32_t lineIndex) +{ + Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0; + void* resultRect; + + textField = (Dali::Toolkit::TextField *)pTextField; + { + try { + resultRect = new Dali::Rect + ((const Dali::Rect &)(Dali::Toolkit::Text::TextGeometry::GetLineBoundingRectangle( *textField, lineIndex))); + } + CALL_CATCH_EXCEPTION(0); + } + + return resultRect; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_TextGeometry_TextEditor_GetLineBoundingRectangle(void * pTextEditor, uint32_t lineIndex) +{ + Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0; + void* resultRect; + + textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; + { + try { + resultRect = new Dali::Rect + ((const Dali::Rect &)(Dali::Toolkit::Text::TextGeometry::GetLineBoundingRectangle( *textEditor, lineIndex))); + } + CALL_CATCH_EXCEPTION(0); + } + + return resultRect; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_TextGeometry_TextLabel_GetCharacterBoundingRectangle(void * pTextLabel, uint32_t charIndex) +{ + Dali::Toolkit::TextLabel *textLabel = (Dali::Toolkit::TextLabel *) 0; + void* resultRect; + + textLabel = (Dali::Toolkit::TextLabel *)pTextLabel; + { + try { + resultRect = new Dali::Rect<> + ((const Dali::Rect<> &)(Dali::Toolkit::Text::TextGeometry::GetCharacterBoundingRectangle( *textLabel, charIndex))); + } + CALL_CATCH_EXCEPTION(0); + } + + return resultRect; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_TextGeometry_TextField_GetCharacterBoundingRectangle(void * pTextField, uint32_t charIndex) +{ + Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0; + void* resultRect; + + textField = (Dali::Toolkit::TextField *)pTextField; + { + try { + resultRect = new Dali::Rect<> + ((const Dali::Rect<> &)(Dali::Toolkit::Text::TextGeometry::GetCharacterBoundingRectangle( *textField, charIndex))); + } + CALL_CATCH_EXCEPTION(0); + } + + return resultRect; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_TextGeometry_TextEditor_GetCharacterBoundingRectangle(void * pTextEditor, uint32_t charIndex) +{ + Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0; + void* resultRect; + + textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; + { + try { + resultRect = new Dali::Rect<> + ((const Dali::Rect<> &)(Dali::Toolkit::Text::TextGeometry::GetCharacterBoundingRectangle( *textEditor, charIndex))); + } + CALL_CATCH_EXCEPTION(0); + } + + return resultRect; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextGeometry_TextLabel_GetCharacterIndexAtPosition(void * pTextLabel, float visualX, float visualY) +{ + Dali::Toolkit::TextLabel *textLabel = (Dali::Toolkit::TextLabel *) 0; + int charIndex; + + textLabel = (Dali::Toolkit::TextLabel *)pTextLabel; + { + try { + charIndex = (int)(Dali::Toolkit::Text::TextGeometry::GetCharacterIndexAtPosition( *textLabel, visualX, visualY)); + } + CALL_CATCH_EXCEPTION(0); + } + + return charIndex; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextGeometry_TextField_GetCharacterIndexAtPosition(void * pTextField, float visualX, float visualY) +{ + Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0; + int charIndex; + + textField = (Dali::Toolkit::TextField *)pTextField; + { + try { + charIndex = (int)(Dali::Toolkit::Text::TextGeometry::GetCharacterIndexAtPosition( *textField, visualX, visualY)); + } + CALL_CATCH_EXCEPTION(0); + } + + return charIndex; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_TextGeometry_TextEditor_GetCharacterIndexAtPosition(void * pTextEditor, float visualX, float visualY) +{ + Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0; + int charIndex; + + textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; + { + try { + charIndex = (int)(Dali::Toolkit::Text::TextGeometry::GetCharacterIndexAtPosition( *textEditor, visualX, visualY)); + } + CALL_CATCH_EXCEPTION(0); + } + + return charIndex; +} + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/dali-toolkit/text-label-wrap.cpp b/dali-csharp-binder/dali-toolkit/text-label-wrap.cpp new file mode 100755 index 00000000..879bdadd --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/text-label-wrap.cpp @@ -0,0 +1,274 @@ +/* + * Copyright (c) 2021 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include + +// INTERNAL INCLUDES +#include + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextLabel) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextLabel) > const *self){ +return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextLabel) > *self,void (*func)(Dali::Toolkit::TextLabel)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextLabel) > *self,void (*func)(Dali::Toolkit::TextLabel)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextLabel) > *self,Dali::Toolkit::TextLabel arg){ + self->Emit( arg ); +} + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT int SWIGSTDCALL CSharp_TextLabel_Property_TEXT_FIT_get() +{ + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelTextLabel::Property::TEXT_FIT; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_SIZE_SCALE_get() +{ + int jresult; + int result; + + result = (int)Dali::Toolkit::DevelTextLabel::Property::FONT_SIZE_SCALE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_FONT_SIZE_SCALE_get() +{ + return (int)Dali::Toolkit::DevelTextLabel::Property::ENABLE_FONT_SIZE_SCALE; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RELATIVE_LINE_SIZE_get() { + + return (int)Dali::Toolkit::DevelTextLabel::Property::RELATIVE_LINE_SIZE; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_GetTextSize(void * pTextLabel, unsigned int start, unsigned int end) +{ + Dali::Toolkit::TextLabel *textLabel = (Dali::Toolkit::TextLabel *) 0; + void* sizeList; + + textLabel = (Dali::Toolkit::TextLabel *)pTextLabel; + { + try { + sizeList = new Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > + ((const Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > &)(Dali::Toolkit::DevelTextLabel::GetTextSize( *textLabel, start, end ))); + } + CALL_CATCH_EXCEPTION(0); + } + + return sizeList; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_GetTextPosition(void * pTextLabel, unsigned int start, unsigned int end) +{ + Dali::Toolkit::TextLabel *textLabel = (Dali::Toolkit::TextLabel *) 0; + void* sizeList; + + textLabel = (Dali::Toolkit::TextLabel *)pTextLabel; + { + try { + sizeList = new Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > + ((const Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > &)(Dali::Toolkit::DevelTextLabel::GetTextPosition( *textLabel, start, end ))); + } + CALL_CATCH_EXCEPTION(0); + } + + return sizeList; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_TextGeometry_TextLabel_GetTextBoundingRectangle(void * pTextLabel, uint32_t startIndex, uint32_t endIndex) +{ + Dali::Toolkit::TextLabel *textLabel = (Dali::Toolkit::TextLabel *) 0; + void* boundingRect; + + textLabel = (Dali::Toolkit::TextLabel *)pTextLabel; + { + try { + boundingRect = new Dali::Rect<> + ((const Dali::Rect<> &)(Dali::Toolkit::DevelTextLabel::GetTextBoundingRectangle( *textLabel, startIndex, endIndex))); + } + CALL_CATCH_EXCEPTION(0); + } + + return boundingRect; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_AnchorClickedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ; + Dali::Toolkit::DevelTextLabel::AnchorClickedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::TextLabel *)jarg1; + { + try { + result = (Dali::Toolkit::DevelTextLabel::AnchorClickedSignalType *)&Dali::Toolkit::DevelTextLabel::AnchorClickedSignal(*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_TextFitChangedSignal(void * jarg1) { + void * jresult ; + Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ; + Dali::Toolkit::DevelTextLabel::TextFitChangedSignalType *result = 0 ; + + arg1 = (Dali::Toolkit::TextLabel *)jarg1; + { + try { + result = (Dali::Toolkit::DevelTextLabel::TextFitChangedSignalType *) &Dali::Toolkit::DevelTextLabel::TextFitChangedSignal(*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextLabelSignal_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void (Dali::Toolkit::TextLabel) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextLabel) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextLabelSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::Toolkit::TextLabel) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextLabel) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextLabelSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::TextLabel) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *) 0 ; + void (*arg2)(Dali::Toolkit::TextLabel) = (void (*)(Dali::Toolkit::TextLabel)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::TextLabel))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextLabelSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::TextLabel) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *) 0 ; + void (*arg2)(Dali::Toolkit::TextLabel) = (void (*)(Dali::Toolkit::TextLabel)) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *)jarg1; + arg2 = (void (*)(Dali::Toolkit::TextLabel))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextLabelSignal_Emit(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::Toolkit::TextLabel) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *) 0 ; + Dali::Toolkit::TextLabel arg2 ; + Dali::Toolkit::TextLabel *argp2 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *)jarg1; + argp2 = (Dali::Toolkit::TextLabel *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextLabel", 0); + return ; + } + arg2 = *argp2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__Emit(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabelSignal() { + void * jresult ; + Dali::Signal< void (Dali::Toolkit::TextLabel) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *)new Dali::Signal< void (Dali::Toolkit::TextLabel) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabelSignal(void * jarg1) { + Dali::Signal< void (Dali::Toolkit::TextLabel) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/dali-toolkit/text-range-wrap.cpp b/dali-csharp-binder/dali-toolkit/text-range-wrap.cpp new file mode 100644 index 00000000..8a93b9bb --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/text-range-wrap.cpp @@ -0,0 +1,136 @@ +/* + * Copyright (c) 2022 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include + +/* Callback for returning strings to C# without leaking memory */ +typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +#ifdef __cplusplus +extern "C" { +#endif + +using namespace Dali::Toolkit::Text; + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Range(void *refRange) { + Range *rangePtr = (Range *)0; + rangePtr = (Range *)refRange; + + { + try { + delete rangePtr; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Range_New(unsigned int argStartIndex, + unsigned int argEndIndex) { + + Range *rangePtr = 0; + { + try { + rangePtr = (Range *)new Range(Range::New(argStartIndex, argEndIndex)); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void *)rangePtr; +} + +SWIGEXPORT unsigned int SWIGSTDCALL +CSharp_Dali_Range_GetStartIndex(void *refRange) { + + Range *rangePtr; + unsigned int result = false; + + rangePtr = (Range *)refRange; + if (!rangePtr) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, + "Attempt to dereference null Range", + 0); + return 0; + } + + { + try { + result = rangePtr->GetStartIndex(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT unsigned int SWIGSTDCALL +CSharp_Dali_Range_GetEndIndex(void *refRange) { + + Range *rangePtr; + unsigned int result = false; + + rangePtr = (Range *)refRange; + if (!rangePtr) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, + "Attempt to dereference null Range", + 0); + return 0; + } + + { + try { + result = rangePtr->GetEndIndex(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT unsigned int SWIGSTDCALL +CSharp_Dali_Range_GetNumberOfIndices(void *refRange) { + + Range *rangePtr; + unsigned int result = false; + + rangePtr = (Range *)refRange; + if (!rangePtr) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, + "Attempt to dereference null Range", + 0); + return 0; + } + + { + try { + result = rangePtr->GetNumberOfIndices(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/text-spannable-api-wrap.cpp b/dali-csharp-binder/dali-toolkit/text-spannable-api-wrap.cpp new file mode 100644 index 00000000..02b645cb --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/text-spannable-api-wrap.cpp @@ -0,0 +1,125 @@ +/* + * Copyright (c) 2022 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include + +/* Callback for returning strings to C# without leaking memory */ +typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +#ifdef __cplusplus +extern "C" { +#endif + +using namespace Dali::Toolkit::Text; + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_TextLabel_SetSpannedText(void *refTextLabel, void *refSpanned) { + + Dali::Toolkit::TextLabel *textLabelPtr = (Dali::Toolkit::TextLabel *)0; + textLabelPtr = (Dali::Toolkit::TextLabel *)refTextLabel; + if (!textLabelPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null TextLabel", 0); + return; + } + + Spanned *spannedPtr = (Spanned *)0; + spannedPtr = (Spanned *)refSpanned; + if (!spannedPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, "Attempt to dereference null Spanned", + 0); + return; + } + + { + try { + SetSpannedText(*textLabelPtr, *spannedPtr); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_TextField_SetSpannedText(void *refTextField, void *refSpanned) { + + Dali::Toolkit::TextField *textFieldPtr = (Dali::Toolkit::TextField *)0; + textFieldPtr = (Dali::Toolkit::TextField *)refTextField; + if (!textFieldPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null TextField", 0); + return; + } + + Spanned *spannedPtr = (Spanned *)0; + spannedPtr = (Spanned *)refSpanned; + if (!spannedPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, "Attempt to dereference null Spanned", + 0); + return; + } + + { + try { + SetSpannedText(*textFieldPtr, *spannedPtr); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_TextEditor_SetSpannedText(void *refTextEditor, void *refSpanned) { + + Dali::Toolkit::TextEditor *textEditorPtr = (Dali::Toolkit::TextEditor *)0; + textEditorPtr = (Dali::Toolkit::TextEditor *)refTextEditor; + if (!textEditorPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null TextEditor", 0); + return; + } + + Spanned *spannedPtr = (Spanned *)0; + spannedPtr = (Spanned *)refSpanned; + if (!spannedPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, "Attempt to dereference null Spanned", + 0); + return; + } + + { + try { + SetSpannedText(*textEditorPtr, *spannedPtr); + } + CALL_CATCH_EXCEPTION(); + } +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/text-spannable-string-wrap.cpp b/dali-csharp-binder/dali-toolkit/text-spannable-string-wrap.cpp new file mode 100644 index 00000000..95ea0681 --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/text-spannable-string-wrap.cpp @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2022 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include + +/* Callback for returning strings to C# without leaking memory */ +typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +#ifdef __cplusplus +extern "C" { +#endif + +using namespace Dali::Toolkit::Text; + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_delete_SpannableString(void *refSpannableString) { + SpannableString *spannablePtr = (SpannableString *)0; + spannablePtr = (SpannableString *)refSpannableString; + + { + try { + delete spannablePtr; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SpannableString_New(char *refText) { + + std::string text = std::string(refText); + SpannableString *spannableStringPtr = 0; + { + try { + spannableStringPtr = + (SpannableString *)new SpannableString(SpannableString::New(text)); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void *)spannableStringPtr; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/text-spannable-wrap.cpp b/dali-csharp-binder/dali-toolkit/text-spannable-wrap.cpp new file mode 100644 index 00000000..d6205bf2 --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/text-spannable-wrap.cpp @@ -0,0 +1,126 @@ +/* + * Copyright (c) 2022 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include + +/* Callback for returning strings to C# without leaking memory */ +typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +#ifdef __cplusplus +extern "C" { +#endif + +using namespace Dali::Toolkit::Text; + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Spannable(void *refSpannable) { + Spannable *spannablePtr = (Spannable *)0; + spannablePtr = (Spannable *)refSpannable; + + { + try { + delete spannablePtr; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Spannable_AttachSpan(void *refSpannable, + void *refSpan, + void *refRange) { + + bool result = false; + + BaseSpan *baseSpanPtr; + baseSpanPtr = (BaseSpan *)refSpan; + if (!baseSpanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null BaseSpan", 0); + return result; + } + + Range *rangePtr; + rangePtr = (Range *)refRange; + if (!rangePtr) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, + "Attempt to dereference null Range", + 0); + return result; + } + + Spannable *spannablePtr; + spannablePtr = (Spannable *)refSpannable; + if (!spannablePtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Spannable", 0); + return result; + } + + { + try { + result = spannablePtr->AttachSpan(*baseSpanPtr, *rangePtr); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Spannable_DetachSpan(void *refSpannable, + void *refSpan) { + + bool result = false; + + BaseSpan *baseSpanPtr; + baseSpanPtr = (BaseSpan *)refSpan; + if (!baseSpanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null BaseSpan", 0); + return result; + } + + Spannable *spannablePtr; + spannablePtr = (Spannable *)refSpannable; + if (!spannablePtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Spannable", 0); + return result; + } + + { + try { + result = spannablePtr->DetachSpan(*baseSpanPtr); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/text-spanned-wrap.cpp b/dali-csharp-binder/dali-toolkit/text-spanned-wrap.cpp new file mode 100644 index 00000000..f1091137 --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/text-spanned-wrap.cpp @@ -0,0 +1,266 @@ +/* + * Copyright (c) 2022 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include + +/* Callback for returning strings to C# without leaking memory */ +typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +#ifdef __cplusplus +extern "C" { +#endif + +using namespace Dali::Toolkit::Text; + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Spanned(void *refSpanned) { + Spanned *spannedPtr = (Spanned *)0; + spannedPtr = (Spanned *)refSpanned; + + { + try { + delete spannedPtr; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Spanned_GetAllSpans(void *refSpanned) { + + Spanned *spannedPtr; + void *result = nullptr; + + spannedPtr = (Spanned *)refSpanned; + if (!spannedPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, "Attempt to dereference null Spanned", + 0); + return 0; + } + + { + try { + result = new std::vector( + (const std::vector &)(spannedPtr->GetAllSpans())); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Spanned_RetrieveAllSpansAndRanges( + void *refSpanned, void *refVectorSpans, void *refVectorRanges) { + + std::vector *spanVectorPtr = (std::vector *)0; + spanVectorPtr = (std::vector *)refVectorSpans; + if (!spanVectorPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null vector", 0); + return; + } + + std::vector *rangeVectorPtr = (std::vector *)0; + rangeVectorPtr = (std::vector *)refVectorRanges; + if (!rangeVectorPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null vector", 0); + return; + } + + Spanned *spannedPtr; + spannedPtr = (Spanned *)refSpanned; + if (!spannedPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, "Attempt to dereference null Spanned", + 0); + return; + } + + { + try { + spannedPtr->RetrieveAllSpansAndRanges(*spanVectorPtr, *rangeVectorPtr); + } + CALL_CATCH_EXCEPTION(); + } + + return; +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_std_vector_BaseSpan_Create() { + void *nuiResult; + std::vector *result = 0; + + { + try { + result = (std::vector *)new std::vector(); + } + CALL_CATCH_EXCEPTION(0); + } + + nuiResult = (void *)result; + return nuiResult; +} + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_std_vector_BaseSpan_Release(void *refVector) { + std::vector *spanPtr = (std::vector *)0; + + spanPtr = (std::vector *)refVector; + { + try { + delete spanPtr; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_std_vector_BaseSpan_ValueOfIndex( + void *refVector, unsigned long argIndex) { + void *nuiResult; + std::vector *spanPtr = (std::vector *)0; + std::vector::size_type itemSize; + std::vector::value_type *result = 0; + + spanPtr = (std::vector *)refVector; + itemSize = (std::vector::size_type)argIndex; + { + try { + result = + (std::vector::value_type *)&(spanPtr)->operator[](itemSize); + } + CALL_CATCH_EXCEPTION(0); + } + + nuiResult = (void *)result; + return nuiResult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_std_vector_BaseSpan_TypeOfIndex( + void *refVector, unsigned long argIndex) { + + Dali::Toolkit::Text::SpanType::Value result; + std::vector *item = (std::vector *)0; + std::vector::size_type itemSize; + std::vector::value_type *spanPtr = 0; + + item = (std::vector *)refVector; + itemSize = (std::vector::size_type)argIndex; + { + try { + spanPtr = + (std::vector::value_type *)&(item)->operator[](itemSize); + result = spanPtr->GetSpanType(); + } + CALL_CATCH_EXCEPTION(0); + } + + int nuiResult = (int)result; + return nuiResult; +} + +SWIGEXPORT int SWIGSTDCALL +CSharp_Dali_std_vector_BaseSpan_Size(void *refVector) { + std::vector *spanVectorPtr = (std::vector *)0; + int size; + + spanVectorPtr = (std::vector *)refVector; + { + try { + size = (spanVectorPtr)->size(); + } + CALL_CATCH_EXCEPTION(0); + } + + return size; +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_std_vector_Range_Create() { + void *nuiResult; + std::vector *result = 0; + + { + try { + result = (std::vector *)new std::vector(); + } + CALL_CATCH_EXCEPTION(0); + } + + nuiResult = (void *)result; + return nuiResult; +} + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_std_vector_Range_Release(void *refVector) { + std::vector *rangePtr = (std::vector *)0; + + rangePtr = (std::vector *)refVector; + { + try { + delete rangePtr; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_std_vector_Range_ValueOfIndex( + void *refVector, unsigned long argIndex) { + void *nuiResult; + std::vector *rangePtr = (std::vector *)0; + std::vector::size_type itemSize; + std::vector::value_type *result = 0; + + rangePtr = (std::vector *)refVector; + itemSize = (std::vector::size_type)argIndex; + { + try { + result = + (std::vector::value_type *)&(rangePtr)->operator[](itemSize); + } + CALL_CATCH_EXCEPTION(0); + } + + nuiResult = (void *)result; + return nuiResult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_std_vector_Range_Size(void *refVector) { + std::vector *rangePtr = (std::vector *)0; + int size; + + rangePtr = (std::vector *)refVector; + { + try { + size = (rangePtr)->size(); + } + CALL_CATCH_EXCEPTION(0); + } + + return size; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/text-spans-wrap.cpp b/dali-csharp-binder/dali-toolkit/text-spans-wrap.cpp new file mode 100644 index 00000000..998db11c --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/text-spans-wrap.cpp @@ -0,0 +1,1254 @@ +/* + * Copyright (c) 2022 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// INTERNAL INCLUDES +#include + +/* Callback for returning strings to C# without leaking memory */ +typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +#ifdef __cplusplus +extern "C" { +#endif + +using namespace Dali::Toolkit::Text; + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseSpan(void *refBaseSpan) { + BaseSpan *baseSpanPtr = (BaseSpan *)0; + baseSpanPtr = (BaseSpan *)refBaseSpan; + + { + try { + delete baseSpanPtr; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BaseSpan_GetSpanType(void *refBaseSpan) { + + Dali::Toolkit::Text::SpanType::Value result; + + BaseSpan *spanPtr = (BaseSpan *)0; + spanPtr = (BaseSpan *)refBaseSpan; + if (!spanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null BaseSpan", 0); + return 0; + } + + { + try { + result = spanPtr->GetSpanType(); + } + CALL_CATCH_EXCEPTION(0); + } + + int nuiResult = (int)result; + return nuiResult; +} + +// ForegroundColorSpan + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_delete_ForegroundColorSpan(void *refSpan) { + ForegroundColorSpan *spanPtr = (ForegroundColorSpan *)0; + spanPtr = (ForegroundColorSpan *)refSpan; + + { + try { + delete spanPtr; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL +CSharp_Dali_ForegroundColorSpan_New(void *argColor) { + + Dali::Vector4 *colorPtr = 0; + colorPtr = (Dali::Vector4 *)argColor; + if (!colorPtr) { + + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::Vector4", 0); + return 0; + } + + ForegroundColorSpan *spanPtr = 0; + { + try { + spanPtr = (ForegroundColorSpan *)new ForegroundColorSpan( + ForegroundColorSpan::New((Dali::Vector4 const &)*colorPtr)); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void *)spanPtr; +} + +SWIGEXPORT void *SWIGSTDCALL +CSharp_Dali_ForegroundColorSpan_GetForegroundColor(void *refSpan) { + + ForegroundColorSpan *spanPtr; + Dali::Vector4 result; + + spanPtr = (ForegroundColorSpan *)refSpan; + if (!spanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null ForegroundColorSpan", 0); + return 0; + } + + { + try { + result = spanPtr->GetForegroundColor(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Vector4((const Dali::Vector4 &)result); +} + +SWIGEXPORT bool SWIGSTDCALL +CSharp_Dali_ForegroundColorSpan_IsForegroundColorDefined(void *refSpan) { + + ForegroundColorSpan *spanPtr; + bool result = false; + + spanPtr = (ForegroundColorSpan *)refSpan; + if (!spanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null ForegroundColorSpan", 0); + return 0; + } + + { + try { + result = spanPtr->IsForegroundColorDefined(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +// CharacterSpacing span + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_delete_CharacterSpacingSpan(void *refSpan) { + CharacterSpacingSpan *spanPtr = (CharacterSpacingSpan *)0; + spanPtr = (CharacterSpacingSpan *)refSpan; + { + try { + delete spanPtr; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL +CSharp_Dali_CharacterSpacingSpan_New(float argCharSpacing) { + float charSpacingPtr = (float)argCharSpacing; + + CharacterSpacingSpan *spanPtr = 0; + { + try { + spanPtr = (CharacterSpacingSpan *)new CharacterSpacingSpan( + CharacterSpacingSpan::New(charSpacingPtr)); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void *)spanPtr; +} + +SWIGEXPORT float SWIGSTDCALL +CSharp_Dali_CharacterSpacingSpan_GetCharacterSpacing(void *refSpan) { + + CharacterSpacingSpan *spanPtr; + float result = 0; + + spanPtr = (CharacterSpacingSpan *)refSpan; + if (!spanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null CharacterSpacingSpan", 0); + return 0; + } + + { + try { + result = spanPtr->GetCharacterSpacing(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL +CSharp_Dali_CharacterSpacingSpan_IsCharacterSpacingDefined(void *refSpan) { + CharacterSpacingSpan *spanPtr; + bool result = false; + + spanPtr = (CharacterSpacingSpan *)refSpan; + if (!spanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null CharacterSpacingSpan", 0); + return 0; + } + + { + try { + result = spanPtr->IsCharacterSpacingDefined(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +// BackgroundColorSpan + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_delete_BackgroundColorSpan(void *refSpan) { + BackgroundColorSpan *spanPtr = (BackgroundColorSpan *)0; + spanPtr = (BackgroundColorSpan *)refSpan; + + { + try { + delete spanPtr; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL +CSharp_Dali_BackgroundColorSpan_New(void *argColor) { + + Dali::Vector4 *colorPtr = 0; + colorPtr = (Dali::Vector4 *)argColor; + if (!colorPtr) { + + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::Vector4", 0); + return 0; + } + + BackgroundColorSpan *spanPtr = 0; + { + try { + spanPtr = (BackgroundColorSpan *)new BackgroundColorSpan( + BackgroundColorSpan::New((Dali::Vector4 const &)*colorPtr)); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void *)spanPtr; +} + +SWIGEXPORT void *SWIGSTDCALL +CSharp_Dali_BackgroundColorSpan_GetBackgroundColor(void *refSpan) { + + BackgroundColorSpan *spanPtr; + Dali::Vector4 result; + + spanPtr = (BackgroundColorSpan *)refSpan; + if (!spanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null BackgroundColorSpan", 0); + return 0; + } + + { + try { + result = spanPtr->GetBackgroundColor(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Vector4((const Dali::Vector4 &)result); +} + +SWIGEXPORT bool SWIGSTDCALL +CSharp_Dali_BackgroundColorSpan_IsBackgroundColorDefined(void *refSpan) { + + BackgroundColorSpan *spanPtr; + bool result = false; + + spanPtr = (BackgroundColorSpan *)refSpan; + if (!spanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null BackgroundColorSpan", 0); + return 0; + } + + { + try { + result = spanPtr->IsBackgroundColorDefined(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +// Italic span + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItalicSpan(void *refSpan) { + ItalicSpan *spanPtr = (ItalicSpan *)0; + spanPtr = (ItalicSpan *)refSpan; + + { + try { + delete spanPtr; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_ItalicSpan_New() { + ItalicSpan *spanPtr = 0; + + { + try { + spanPtr = (ItalicSpan *)new ItalicSpan(ItalicSpan::New()); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void *)spanPtr; +} + +// Bold span + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BoldSpan(void *refSpan) { + + BoldSpan *spanPtr = (BoldSpan *)0; + spanPtr = (BoldSpan *)refSpan; + + { + try { + delete spanPtr; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_BoldSpan_New() { + BoldSpan *spanPtr = 0; + + { + try { + spanPtr = (BoldSpan *)new BoldSpan(BoldSpan::New()); + } + CALL_CATCH_EXCEPTION(0); + } + + return (void *)spanPtr; +} + +// FontSpan +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FontSpan(void *refSpan) { + + FontSpan *spanPtr = (FontSpan *)0; + spanPtr = (FontSpan *)refSpan; + + { + try { + delete spanPtr; + } + + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_FontSpan_New(char *argFamilyName, + float argSize, + int argWeight, + int argWidth, + int argSlant) { + + std::string *familyName = 0; + if (!argFamilyName) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, + "null string", 0); + + return 0; + } + + std::string argFamilyName_str(argFamilyName); + familyName = &argFamilyName_str; + float size = (float)argSize; + + Dali::TextAbstraction::FontWeight::Type weight; + weight = (Dali::TextAbstraction::FontWeight::Type)argWeight; + Dali::TextAbstraction::FontWidth::Type width; + width = (Dali::TextAbstraction::FontWidth::Type)argWidth; + Dali::TextAbstraction::FontSlant::Type slant; + slant = (Dali::TextAbstraction::FontSlant::Type)argSlant; + + FontSpan *spanPtr = 0; + { + try { + spanPtr = (FontSpan *)new FontSpan(FontSpan::New( + (std::string const &)*familyName, size, weight, width, slant)); + } + + CALL_CATCH_EXCEPTION(0); + } + + return (void *)spanPtr; +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_FontSpan_GetFamilyName(void *refSpan) { + + FontSpan *spanPtr; + std::string result; + spanPtr = (FontSpan *)refSpan; + + if (!spanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null FontSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->GetFamilyName(); + } + + CALL_CATCH_EXCEPTION(0); + } + + char *nuiResult = SWIG_csharp_string_callback(result.c_str()); + + return nuiResult; +} + +SWIGEXPORT bool SWIGSTDCALL + +CSharp_Dali_FontSpan_IsFamilyNameDefined(void *refSpan) { + + FontSpan *spanPtr; + bool result = false; + + spanPtr = (FontSpan *)refSpan; + if (!spanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null FontSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->IsFamilyNameDefined(); + } + + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontSpan_GetWeight(void *refSpan) { + + FontSpan *spanPtr; + Dali::TextAbstraction::FontWeight::Type result; + + spanPtr = (FontSpan *)refSpan; + if (!spanPtr) { + + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null FontSpan", 0); + + return 0; + } + + { + + try { + result = (Dali::TextAbstraction::FontWeight::Type)spanPtr->GetWeight(); + } + + CALL_CATCH_EXCEPTION(0); + } + + int nuiResult = (int)result; + return nuiResult; +} + +SWIGEXPORT bool SWIGSTDCALL +CSharp_Dali_FontSpan_IsWeightDefined(void *refSpan) { + + FontSpan *spanPtr; + bool result = false; + + spanPtr = (FontSpan *)refSpan; + if (!spanPtr) { + + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null FontSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->IsWeightDefined(); + } + + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontSpan_GetWidth(void *refSpan) { + + FontSpan *spanPtr; + + Dali::TextAbstraction::FontWidth::Type result; + + spanPtr = (FontSpan *)refSpan; + if (!spanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null FontSpan", 0); + + return 0; + } + + { + try { + result = (Dali::TextAbstraction::FontWidth::Type)spanPtr->GetWidth(); + } + + CALL_CATCH_EXCEPTION(0); + } + + int nuiResult = (int)result; + return nuiResult; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FontSpan_IsWidthDefined(void *refSpan) { + + FontSpan *spanPtr; + bool result = false; + + spanPtr = (FontSpan *)refSpan; + if (!spanPtr) { + + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null FontSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->IsWidthDefined(); + } + + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontSpan_GetSlant(void *refSpan) { + + FontSpan *spanPtr; + Dali::TextAbstraction::FontSlant::Type result; + + spanPtr = (FontSpan *)refSpan; + if (!spanPtr) { + + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null FontSpan", 0); + + return 0; + } + + { + + try { + result = (Dali::TextAbstraction::FontSlant::Type)spanPtr->GetSlant(); + } + + CALL_CATCH_EXCEPTION(0); + } + + int nuiResult = (int)result; + return nuiResult; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FontSpan_IsSlantDefined(void *refSpan) { + + FontSpan *spanPtr; + bool result = false; + + spanPtr = (FontSpan *)refSpan; + if (!spanPtr) { + + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null FontSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->IsSlantDefined(); + } + + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FontSpan_GetSize(void *refSpan) { + + FontSpan *spanPtr; + float result; + + spanPtr = (FontSpan *)refSpan; + if (!spanPtr) { + + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null FontSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->GetSize(); + } + + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FontSpan_IsSizeDefined(void *refSpan) { + + FontSpan *spanPtr; + bool result = false; + + spanPtr = (FontSpan *)refSpan; + if (!spanPtr) { + + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null FontSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->IsSizeDefined(); + } + + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +// UnderlineSpan + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_UnderlineSpan(void *refSpan) { + + UnderlineSpan *spanPtr = (UnderlineSpan *)0; + spanPtr = (UnderlineSpan *)refSpan; + { + try { + delete spanPtr; + } + + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_UnderlineSpan_New() { + + UnderlineSpan *spanPtr = 0; + + { + try { + spanPtr = (UnderlineSpan *)new UnderlineSpan(UnderlineSpan::New()); + } + + CALL_CATCH_EXCEPTION(0); + } + + return (void *)spanPtr; +} + +SWIGEXPORT void *SWIGSTDCALL +CSharp_Dali_UnderlineSpan_NewSolid(void *argColor, float argHeight) { + + float height = (float)argHeight; + Dali::Vector4 *colorPtr = 0; + colorPtr = (Dali::Vector4 *)argColor; + + if (!colorPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::Vector4", 0); + + return 0; + } + + UnderlineSpan *spanPtr = 0; + { + try { + spanPtr = (UnderlineSpan *)new UnderlineSpan( + UnderlineSpan::NewSolid((Dali::Vector4 const &)*colorPtr, height)); + } + + CALL_CATCH_EXCEPTION(0); + } + + return (void *)spanPtr; +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_UnderlineSpan_NewDashed( + void *argColor, float argHeight, float argDashGap, float argDashWidth) { + + float height = (float)argHeight; + float dashGap = (float)argDashGap; + float dashWidth = (float)argDashWidth; + + Dali::Vector4 *colorPtr = 0; + colorPtr = (Dali::Vector4 *)argColor; + + if (!colorPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::Vector4", 0); + + return 0; + } + + UnderlineSpan *spanPtr = 0; + { + try { + spanPtr = (UnderlineSpan *)new UnderlineSpan(UnderlineSpan::NewDashed( + (Dali::Vector4 const &)*colorPtr, height, dashGap, dashWidth)); + } + + CALL_CATCH_EXCEPTION(0); + } + + return (void *)spanPtr; +} + +SWIGEXPORT void *SWIGSTDCALL +CSharp_Dali_UnderlineSpan_NewDouble(void *argColor, float argHeight) { + + float height = (float)argHeight; + Dali::Vector4 *colorPtr = 0; + colorPtr = (Dali::Vector4 *)argColor; + + if (!colorPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::Vector4", 0); + + return 0; + } + + UnderlineSpan *spanPtr = 0; + { + try { + spanPtr = (UnderlineSpan *)new UnderlineSpan( + UnderlineSpan::NewDouble((Dali::Vector4 const &)*colorPtr, height)); + } + + CALL_CATCH_EXCEPTION(0); + } + + return (void *)spanPtr; +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_UnderlineSpan_GetColor(void *refSpan) { + + UnderlineSpan *spanPtr; + Dali::Vector4 result; + + spanPtr = (UnderlineSpan *)refSpan; + if (!spanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null UnderlineSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->GetColor(); + } + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Vector4((const Dali::Vector4 &)result); +} + +SWIGEXPORT bool SWIGSTDCALL + +CSharp_Dali_UnderlineSpan_IsColorDefined(void *refSpan) { + + UnderlineSpan *spanPtr; + bool result = false; + spanPtr = (UnderlineSpan *)refSpan; + + if (!spanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null UnderlineSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->IsColorDefined(); + } + + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_UnderlineSpan_GetType(void *refSpan) { + + UnderlineSpan *spanPtr; + Dali::Toolkit::Text::Underline::Type result; + + spanPtr = (UnderlineSpan *)refSpan; + if (!spanPtr) { + + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null UnderlineSpan", 0); + + return 0; + } + + { + try { + result = (Dali::Toolkit::Text::Underline::Type)spanPtr->GetType(); + } + + CALL_CATCH_EXCEPTION(0); + } + + int nuiResult = (int)result; + return nuiResult; +} + +SWIGEXPORT bool SWIGSTDCALL +CSharp_Dali_UnderlineSpan_IsTypeDefined(void *refSpan) { + + UnderlineSpan *spanPtr; + bool result = false; + + spanPtr = (UnderlineSpan *)refSpan; + if (!spanPtr) { + + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null UnderlineSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->IsTypeDefined(); + } + + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT float SWIGSTDCALL +CSharp_Dali_UnderlineSpan_GetHeight(void *refSpan) { + + UnderlineSpan *spanPtr; + float result; + + spanPtr = (UnderlineSpan *)refSpan; + if (!spanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null UnderlineSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->GetHeight(); + } + + CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL +CSharp_Dali_UnderlineSpan_IsHeightDefined(void *refSpan) { + + UnderlineSpan *spanPtr; + bool result = false; + + spanPtr = (UnderlineSpan *)refSpan; + if (!spanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null UnderlineSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->IsHeightDefined(); + } + + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT float SWIGSTDCALL +CSharp_Dali_UnderlineSpan_GetDashGap(void *refSpan) { + + UnderlineSpan *spanPtr; + float result; + + spanPtr = (UnderlineSpan *)refSpan; + if (!spanPtr) { + + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null UnderlineSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->GetDashGap(); + } + + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL +CSharp_Dali_UnderlineSpan_IsDashGapDefined(void *refSpan) { + + UnderlineSpan *spanPtr; + bool result = false; + + spanPtr = (UnderlineSpan *)refSpan; + if (!spanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null UnderlineSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->IsDashGapDefined(); + } + + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT float SWIGSTDCALL +CSharp_Dali_UnderlineSpan_GetDashWidth(void *refSpan) { + + UnderlineSpan *spanPtr; + float result; + + spanPtr = (UnderlineSpan *)refSpan; + if (!spanPtr) { + + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null UnderlineSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->GetDashWidth(); + } + + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL +CSharp_Dali_UnderlineSpan_IsDashWidthDefined(void *refSpan) { + + UnderlineSpan *spanPtr; + bool result = false; + + spanPtr = (UnderlineSpan *)refSpan; + if (!spanPtr) { + + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null UnderlineSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->IsDashWidthDefined(); + } + + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +// StrikethroughSpan + +SWIGEXPORT void SWIGSTDCALL +CSharp_Dali_delete_StrikethroughSpan(void *refSpan) { + + StrikethroughSpan *spanPtr = (StrikethroughSpan *)0; + spanPtr = (StrikethroughSpan *)refSpan; + { + try { + delete spanPtr; + } + + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_StrikethroughSpan_New() { + + StrikethroughSpan *spanPtr = 0; + { + try { + spanPtr = + (StrikethroughSpan *)new StrikethroughSpan(StrikethroughSpan::New()); + } + + CALL_CATCH_EXCEPTION(0); + } + + return (void *)spanPtr; +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_StrikethroughSpan_New_color_height( + void *argColor, float argHeight) { + + float height = (float)argHeight; + Dali::Vector4 *colorPtr = 0; + colorPtr = (Dali::Vector4 *)argColor; + + if (!colorPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null Dali::Vector4", 0); + + return 0; + } + + StrikethroughSpan *spanPtr = 0; + { + try { + spanPtr = (StrikethroughSpan *)new StrikethroughSpan( + StrikethroughSpan::New((Dali::Vector4 const &)*colorPtr, height)); + } + + CALL_CATCH_EXCEPTION(0); + } + + return (void *)spanPtr; +} + +SWIGEXPORT void *SWIGSTDCALL +CSharp_Dali_StrikethroughSpan_GetColor(void *refSpan) { + + StrikethroughSpan *spanPtr; + Dali::Vector4 result; + + spanPtr = (StrikethroughSpan *)refSpan; + if (!spanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null StrikethroughSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->GetColor(); + } + + CALL_CATCH_EXCEPTION(0); + } + + return new Dali::Vector4((const Dali::Vector4 &)result); +} + +SWIGEXPORT bool SWIGSTDCALL +CSharp_Dali_StrikethroughSpan_IsColorDefined(void *refSpan) { + + StrikethroughSpan *spanPtr; + bool result = false; + + spanPtr = (StrikethroughSpan *)refSpan; + if (!spanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null StrikethroughSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->IsColorDefined(); + } + + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT float SWIGSTDCALL +CSharp_Dali_StrikethroughSpan_GetHeight(void *refSpan) { + + StrikethroughSpan *spanPtr; + float result; + + spanPtr = (StrikethroughSpan *)refSpan; + if (!spanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null StrikethroughSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->GetHeight(); + } + + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT bool SWIGSTDCALL +CSharp_Dali_StrikethroughSpan_IsHeightDefined(void *refSpan) { + + StrikethroughSpan *spanPtr; + bool result = false; + + spanPtr = (StrikethroughSpan *)refSpan; + if (!spanPtr) { + SWIG_CSharpSetPendingExceptionArgument( + SWIG_CSharpArgumentNullException, + "Attempt to dereference null StrikethroughSpan", 0); + + return 0; + } + + { + try { + result = spanPtr->IsHeightDefined(); + } + + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/text-utils-wrap.cpp b/dali-csharp-binder/dali-toolkit/text-utils-wrap.cpp new file mode 100755 index 00000000..2b8d3ddc --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/text-utils-wrap.cpp @@ -0,0 +1,870 @@ +/* + * Copyright (c) 2020 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include + +// INTERNAL INCLUDES +#include + +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RendererParameters_0() { + void * jresult ; + Dali::Toolkit::DevelText::RendererParameters *result = 0 ; + { + try { + result = (Dali::Toolkit::DevelText::RendererParameters *)new Dali::Toolkit::DevelText::RendererParameters(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RendererParameters(void * jarg1) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_text_set(void * jarg1, char * jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + std::string arg2_str(jarg2); + arg2 = &arg2_str; + try { + if (arg1) (arg1)->text = *arg2; + } CALL_CATCH_EXCEPTION(); +} + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_RendererParameters_text_get(void * jarg1) { + char * jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + std::string * result = 0; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + try { + result = (std::string *) & ((arg1)->text); + } CALL_CATCH_EXCEPTION(0); + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_horizontalAlignment_set(void * jarg1, char * jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + std::string arg2_str(jarg2); + arg2 = &arg2_str; + if (arg1) (arg1)->horizontalAlignment = *arg2; +} + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_RendererParameters_horizontalAlignment_get(void * jarg1) { + char * jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + std::string * result = 0; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + try { + result = (std::string *) & ((arg1)->horizontalAlignment); + } CALL_CATCH_EXCEPTION(0); + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_verticalAlignment_set(void * jarg1, char * jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + std::string arg2_str(jarg2); + arg2 = &arg2_str; + if (arg1) (arg1)->verticalAlignment = *arg2; +} + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_RendererParameters_verticalAlignment_get(void * jarg1) { + char * jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + std::string * result = 0; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + try { + result = (std::string *) & ((arg1)->verticalAlignment); + } CALL_CATCH_EXCEPTION(0); + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_fontFamily_set(void * jarg1, char * jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + std::string arg2_str(jarg2); + arg2 = &arg2_str; + if (arg1) (arg1)->fontFamily = * arg2; +} + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_RendererParameters_fontFamily_get(void * jarg1) { + char * jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + std::string * result = 0; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + try { + result = (std::string *) &((arg1)->fontFamily); + } CALL_CATCH_EXCEPTION(0); + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_fontWeight_set(void * jarg1, char * jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + std::string arg2_str(jarg2); + arg2 = &arg2_str; + if (arg1) (arg1)->fontWeight = *arg2; +} + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_RendererParameters_fontWeight_get(void * jarg1) { + char * jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + std::string * result = 0; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + try { + result = (std::string *) &((arg1)->fontWeight); + } CALL_CATCH_EXCEPTION(0); + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_fontWidth_set(void * jarg1, char * jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + std::string arg2_str(jarg2); + arg2 = &arg2_str; + if (arg1) (arg1)->fontWidth = *arg2; +} + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_RendererParameters_fontWidth_get(void * jarg1) { + char * jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + std::string * result = 0; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + try { + result = (std::string *) &((arg1)->fontWidth); + } CALL_CATCH_EXCEPTION(0); + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_fontSlant_set(void * jarg1, char * jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + std::string arg2_str(jarg2); + arg2 = &arg2_str; + if (arg1) (arg1)->fontSlant = *arg2; +} + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_RendererParameters_fontSlant_get(void * jarg1) { + char * jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + std::string * result = 0; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + try { + result = (std::string *) & ((arg1)->fontSlant); + } CALL_CATCH_EXCEPTION(0); + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_layout_set(void * jarg1, char * jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + std::string arg2_str(jarg2); + arg2 = &arg2_str; + if (arg1) (arg1)->layout = *arg2; +} + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_RendererParameters_layout_get(void * jarg1) { + char * jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + std::string * result = 0; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + try { + result = (std::string *) & ((arg1)->layout); + } CALL_CATCH_EXCEPTION(0); + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_circularAlignment_set(void * jarg1, char * jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + std::string *arg2 = 0 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + std::string arg2_str(jarg2); + arg2 = &arg2_str; + if (arg1) (arg1)->circularAlignment = *arg2; +} + +SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_RendererParameters_circularAlignment_get(void * jarg1) { + char * jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + std::string * result = 0; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + try { + result = (std::string *) & ((arg1)->circularAlignment); + } CALL_CATCH_EXCEPTION(0); + jresult = SWIG_csharp_string_callback(result->c_str()); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_textColor_set(void * jarg1, void * jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + Dali::Vector4 *arg2 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (arg1) (arg1)->textColor = *arg2; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RendererParameters_textColor_get(void * jarg1) { + void * jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + Dali::Vector4* result; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + result = (Dali::Vector4 *) new Dali::Vector4((arg1)->textColor); + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_fontSize_set(void * jarg1, float jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->fontSize = arg2; +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RendererParameters_fontSize_get(void * jarg1) { + float jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + float result; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + result = (float) ((arg1)->fontSize); + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_textWidth_set(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + arg2 = (unsigned int)jarg2; + if (arg1) (arg1)->textWidth = arg2; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RendererParameters_textWidth_get(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + result = (unsigned int) ((arg1)->textWidth); + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_textHeight_set(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + arg2 = (unsigned int)jarg2; + if (arg1) (arg1)->textHeight = arg2; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RendererParameters_textHeight_get(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + result = (unsigned int) ((arg1)->textHeight); + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_radius_set(void * jarg1, unsigned int jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + unsigned int arg2 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + arg2 = (unsigned int)jarg2; + if (arg1) (arg1)->radius = arg2; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RendererParameters_radius_get(void * jarg1) { + unsigned int jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + unsigned int result; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + result = (unsigned int) ((arg1)->radius); + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_beginAngle_set(void * jarg1, float jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->beginAngle = arg2; +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RendererParameters_beginAngle_get(void * jarg1) { + float jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + float result; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + result = (float) ((arg1)->beginAngle); + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_incrementAngle_set(void * jarg1, float jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->incrementAngle = arg2; +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RendererParameters_incrementAngle_get(void * jarg1) { + float jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + float result; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + result = (float) ((arg1)->incrementAngle); + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_ellipsisEnabled_set(void * jarg1, bool jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + bool arg2 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + arg2 = (bool)jarg2; + if (arg1) (arg1)->ellipsisEnabled = arg2; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RendererParameters_ellipsisEnabled_get(void * jarg1) { + bool jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + result = (bool) ((arg1)->ellipsisEnabled); + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_markupEnabled_set(void * jarg1, bool jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + bool arg2 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + arg2 = (bool)jarg2; + if (arg1) (arg1)->markupEnabled = arg2; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RendererParameters_markupEnabled_get(void * jarg1) { + bool jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + result = (bool) ((arg1)->markupEnabled); + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_isTextColorSet_set(void * jarg1, bool jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + bool arg2 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + arg2 = (bool)jarg2; + if (arg1) (arg1)->isTextColorSet = arg2; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RendererParameters_isTextColorSet_get(void * jarg1) { + bool jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + result = (bool) ((arg1)->isTextColorSet); + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_minLineSize_set(void * jarg1, float jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + float arg2 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->minLineSize = arg2; +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RendererParameters_minLineSize_get(void * jarg1) { + float jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + float result; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + result = (float) ((arg1)->minLineSize); + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_padding_set(void * jarg1, void * jarg2) { + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + Dali::Extents *arg2 ; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + arg2 = (Dali::Extents *)jarg2; + if (arg1) (arg1)->padding = *arg2; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RendererParameters_padding_get(void * jarg1) { + void * jresult ; + Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; + Dali::Extents * result; + + arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; + result = (Dali::Extents *) new Dali::Extents((arg1)->padding); + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EmbeddedItemInfo_0() { + void * jresult ; + Dali::Toolkit::DevelText::EmbeddedItemInfo *result = 0 ; + { + try { + result = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)new Dali::Toolkit::DevelText::EmbeddedItemInfo(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EmbeddedItemInfo(void * jarg1) { + Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; + + arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_characterIndex_set(void * jarg1, Dali::TextAbstraction::CharacterIndex jarg2) { + Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; + Dali::TextAbstraction::CharacterIndex arg2 ; + + arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; + arg2 = (Dali::TextAbstraction::CharacterIndex)jarg2; + if (arg1) (arg1)->characterIndex = arg2; +} + +SWIGEXPORT Dali::TextAbstraction::CharacterIndex SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_characterIndex_get(void * jarg1) { + Dali::TextAbstraction::CharacterIndex jresult ; + Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; + Dali::TextAbstraction::CharacterIndex result; + + arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; + result = (Dali::TextAbstraction::CharacterIndex) ((arg1)->characterIndex); + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_glyphIndex_set(void * jarg1, Dali::TextAbstraction::GlyphIndex jarg2) { + Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; + Dali::TextAbstraction::GlyphIndex arg2 ; + + arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; + arg2 = (Dali::TextAbstraction::GlyphIndex)jarg2; + if (arg1) (arg1)->glyphIndex = arg2; +} + +SWIGEXPORT Dali::TextAbstraction::GlyphIndex SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_glyphIndex_get(void * jarg1) { + Dali::TextAbstraction::GlyphIndex jresult ; + Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; + Dali::TextAbstraction::GlyphIndex result; + + arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; + result = (Dali::TextAbstraction::GlyphIndex) ((arg1)->glyphIndex); + jresult = result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_position_set(void * jarg1, void * jarg2) { + Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; + Dali::Vector2 * arg2 ; + + arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (arg1) (arg1)->position = *arg2; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_position_get(void * jarg1) { + void * jresult ; + Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; + Dali::Vector2 * result; + + arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; + result = (Dali::Vector2 *) & ((arg1)->position); + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_size_set(void * jarg1, void * jarg2) { + Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; + Dali::Size* arg2 ; + + arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; + arg2 = (Dali::Size *)jarg2; + if (arg1) (arg1)->size = *arg2; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_size_get(void * jarg1) { + void * jresult ; + Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; + Dali::Size * result; + + arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; + result = (Dali::Size *) & ((arg1)->size); + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_rotatedSize_set(void * jarg1, void * jarg2) { + Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; + Dali::Size * arg2 ; + + arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; + arg2 = (Dali::Size *)jarg2; + if (arg1) (arg1)->rotatedSize = * arg2; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_rotatedSize_get(void * jarg1) { + void * jresult ; + Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; + Dali::Size * result; + + arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; + result = (Dali::Size *) & ((arg1)->rotatedSize); + jresult = (void *) result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_angle_set(void * jarg1, void * jarg2) { + Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; + Dali::Degree *arg2 ; + + arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; + arg2 = (Dali::Degree *)jarg2; + if (arg1) (arg1)->angle = *arg2; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_angle_get(void * jarg1) { + void * jresult ; + Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; + Dali::Degree * result; + + arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; + result = (Dali::Degree *) & ((arg1)->angle); + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_colorBlendingMode_set(void * jarg1, Dali::TextAbstraction::ColorBlendingMode jarg2) { + Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; + Dali::TextAbstraction::ColorBlendingMode arg2 ; + + arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; + arg2 = (Dali::TextAbstraction::ColorBlendingMode)jarg2; + if (arg1) (arg1)->colorBlendingMode = arg2; +} + +SWIGEXPORT Dali::TextAbstraction::ColorBlendingMode SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_colorBlendingMode_get(void * jarg1) { + Dali::TextAbstraction::ColorBlendingMode jresult ; + Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; + Dali::TextAbstraction::ColorBlendingMode result; + + arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; + result = (Dali::TextAbstraction::ColorBlendingMode) ((arg1)->colorBlendingMode); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ShadowParameters_0() { + void * jresult ; + Dali::Toolkit::DevelText::ShadowParameters *result = 0 ; + { + try { + result = (Dali::Toolkit::DevelText::ShadowParameters *)new Dali::Toolkit::DevelText::ShadowParameters(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ShadowParameters(void * jarg1) { + Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; + + arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ShadowParameters_input_set(void * jarg1, void * jarg2) { + Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; + Dali::Devel::PixelBuffer *arg2 ; + + arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; + arg2 = (Dali::Devel::PixelBuffer *)jarg2; + if (arg1) (arg1)->input = *arg2; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ShadowParameters_input_get(void * jarg1) { + void * jresult ; + Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; + Dali::Devel::PixelBuffer result; + + arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; + result = (Dali::Devel::PixelBuffer) ((arg1)->input); + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ShadowParameters_textColor_set(void * jarg1, void * jarg2) { + Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; + Dali::Vector4 *arg2 ; + + arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (arg1) (arg1)->textColor = *arg2; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ShadowParameters_textColor_get(void * jarg1) { + void * jresult ; + Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; + Dali::Vector4 * result; + + arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; + result = (Dali::Vector4 *)new Dali::Vector4((arg1)->textColor); + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ShadowParameters_color_set(void * jarg1, void * jarg2) { + Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; + Dali::Vector4 * arg2 ; + + arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; + arg2 = (Dali::Vector4 *)jarg2; + if (arg1) (arg1)->color = *arg2; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ShadowParameters_color_get(void * jarg1) { + void * jresult ; + Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; + Dali::Vector4 * result; + + arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; + result = (Dali::Vector4 *) & ((arg1)->color); + jresult = (void *) result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ShadowParameters_offset_set(void * jarg1, void * jarg2) { + Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; + Dali::Vector2 * arg2 ; + + arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; + arg2 = (Dali::Vector2 *)jarg2; + if (arg1) (arg1)->offset = *arg2; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ShadowParameters_offset_get(void * jarg1) { + void * jresult ; + Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; + Dali::Vector2 * result; + + arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; + result = (Dali::Vector2 *) & ((arg1)->offset); + jresult = (void *) result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ShadowParameters_blendShadow_set(void * jarg1, bool jarg2) { + Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; + bool arg2 ; + + arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; + arg2 = (bool)jarg2; + if (arg1) (arg1)->blendShadow = arg2; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ShadowParameters_blendShadow_get(void * jarg1) { + bool jresult ; + Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; + bool result; + + arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; + result = (bool) ((arg1)->blendShadow); + jresult = result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextUtils_Render(void* jarg1, void** jarg2, int* jarg3, int* jarg4) { + void* jresult; + Dali::Toolkit::DevelText::RendererParameters* arg1 = (Dali::Toolkit::DevelText::RendererParameters*)(jarg1); + + Dali::Vector embeddedItemLayout; + + Dali::Devel::PixelBuffer result = Dali::Toolkit::DevelText::Render(*arg1, embeddedItemLayout); + void** arg2 = jarg2; + uint16_t* arg3 = (uint16_t*)(jarg3); + uint16_t* arg4 = (uint16_t*)(jarg4); + + Dali::Toolkit::DevelText::EmbeddedItemInfo* array = new Dali::Toolkit::DevelText::EmbeddedItemInfo[embeddedItemLayout.Count()]; + int count = 0; + for( const auto& itemLayout : embeddedItemLayout ) + { + array[count++] = itemLayout; + } + *arg2 = (void *) array; + *arg3 = count; + *arg4 = sizeof(struct Dali::Toolkit::DevelText::EmbeddedItemInfo); + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextUtils_CreateShadow(void* jarg1) { + void* jresult; + Dali::Toolkit::DevelText::ShadowParameters* arg1 = (Dali::Toolkit::DevelText::ShadowParameters*)(jarg1); + + Dali::Devel::PixelBuffer result = Dali::Toolkit::DevelText::CreateShadow(*arg1); + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextUtils_ConvertToRgba8888(void* jarg1, void* jarg2, bool jarg3 ) { + void* jresult; + Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *)jarg1; + Dali::Vector4 *arg2 = (Dali::Vector4 *)jarg2; + bool arg3 = (bool)jarg3; + + Dali::Devel::PixelBuffer result = Dali::Toolkit::DevelText::ConvertToRgba8888(*arg1, *arg2, arg3); + jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextUtils_UpdateBuffer(void* jarg1, void* jarg2, unsigned int jarg3, unsigned int jarg4, bool jarg5) { + Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *)jarg1; + Dali::Devel::PixelBuffer *arg2 = (Dali::Devel::PixelBuffer *)jarg2; + unsigned int arg3 = (unsigned int)jarg3; + unsigned int arg4 = (unsigned int)jarg4; + bool arg5 = (bool)jarg5; + + Dali::Toolkit::DevelText::UpdateBuffer(*arg1, *arg2, arg3, arg4, arg5); +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextUtils_GetLastCharacterIndex(void* jarg1) { + void* jresult; + Dali::Property::Array *result = 0 ; + Dali::Toolkit::DevelText::RendererParameters* arg1 = (Dali::Toolkit::DevelText::RendererParameters*)(jarg1); + + if(!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelText::RendererParameters is null", 0); + result = (Dali::Property::Array *)new Dali::Property::Array(); + jresult = (void *)result; + return jresult; + } + + try { + Dali::Property::Array result1 = Dali::Toolkit::DevelText::GetLastCharacterIndex(*arg1); + result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)result1); + } CALL_CATCH_EXCEPTION(0); + jresult = (void *)result; + return jresult; +} + + + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/dali-toolkit/transition-base-wrap.cpp b/dali-csharp-binder/dali-toolkit/transition-base-wrap.cpp new file mode 100755 index 00000000..71af2c4c --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/transition-base-wrap.cpp @@ -0,0 +1,230 @@ +/* + * Copyright (c) 2021 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_TransitionBase() + { + void *jresult; + Dali::Toolkit::TransitionBase *result = 0; + + { + try + { + result = (Dali::Toolkit::TransitionBase *)new Dali::Toolkit::TransitionBase(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_TransitionBase_New() + { + void *jresult; + Dali::Toolkit::TransitionBase result; + { + try + { + result = Dali::Toolkit::TransitionBase::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::TransitionBase((const Dali::Toolkit::TransitionBase &)result); + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionBase(void *nuiTransitionBase) + { + Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)0; + + transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase; + { + try + { + delete transition; + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_TransitionBase_Set(void *nuiTransitionBase) + { + Dali::Toolkit::TransitionBase *newTransition = 0; + Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase; + if (!transition) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionBase const & type is null", 0); + return 0; + } + { + try + { + newTransition = (Dali::Toolkit::TransitionBase *)new Dali::Toolkit::TransitionBase((Dali::Toolkit::TransitionBase const &)*transition); + } + CALL_CATCH_EXCEPTION(0); + } + void *result; + result = (void *)newTransition; + return result; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_TransitionBase_Assign(void *nuiDestination, void *nuiSource) + { + void *jresult; + Dali::Toolkit::TransitionBase *destination = (Dali::Toolkit::TransitionBase *)0; + Dali::Toolkit::TransitionBase *source = 0; + Dali::Toolkit::TransitionBase *result = 0; + + destination = (Dali::Toolkit::TransitionBase *)nuiDestination; + source = (Dali::Toolkit::TransitionBase *)nuiSource; + + if (!source) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionBase const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Toolkit::TransitionBase *)&(destination)->operator=((Dali::Toolkit::TransitionBase const &)*source); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TransitionBase_SetTimePeriod(void *nuiTransitionBase, void *nuiTimePeriod) + { + Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase; + Dali::TimePeriod *timePeriod = (Dali::TimePeriod *)nuiTimePeriod; + + if (!transition || !timePeriod) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); + return; + } + { + try + { + (transition)->SetTimePeriod(*timePeriod); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_TransitionBase_GetTimePeriod(void *nuiTransitionBase) + { + Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase; + Dali::TimePeriod timePeriod(0); + { + try + { + timePeriod = ((Dali::Toolkit::TransitionBase const *)transition)->GetTimePeriod(); + } + CALL_CATCH_EXCEPTION(0); + } + void *result = new Dali::TimePeriod((const Dali::TimePeriod &)timePeriod); + return result; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TransitionBase_SetAlphaFunction(void *nuiTransitionBase, void *nuiAlphaFunction) + { + Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase; + Dali::AlphaFunction *alphaFunction = (Dali::AlphaFunction *)nuiAlphaFunction; + + if (!transition || !alphaFunction) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); + return; + } + { + try + { + (transition)->SetAlphaFunction(*alphaFunction); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_TransitionBase_GetAlphaFunction(void *nuiTransitionBase) + { + Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase; + Dali::AlphaFunction alphaFunction; + { + try + { + alphaFunction = ((Dali::Toolkit::TransitionBase const *)transition)->GetAlphaFunction(); + } + CALL_CATCH_EXCEPTION(0); + } + void *result = new Dali::AlphaFunction((const Dali::AlphaFunction &)alphaFunction); + return result; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TransitionBase_TransitionWithChild(void *nuiTransitionBase, bool nuiTransitionWithChild) + { + Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase; + + if (!transition) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); + return; + } + { + try + { + (transition)->TransitionWithChild(nuiTransitionWithChild); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TransitionBase_SetAppearingTransition(void *nuiTransitionBase, bool nuiAppearingTransition) + { + Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase; + + if (!transition) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); + return; + } + { + try + { + (transition)->SetAppearingTransition(nuiAppearingTransition); + } + CALL_CATCH_EXCEPTION(); + } + } + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/transition-effects-wrap.cpp b/dali-csharp-binder/dali-toolkit/transition-effects-wrap.cpp new file mode 100755 index 00000000..b325735e --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/transition-effects-wrap.cpp @@ -0,0 +1,503 @@ +/* + * Copyright (c) 2019 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include +#include +#include + +// INTERNAL INCLUDES +#include + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__Empty(Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > const *self) { + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__GetConnectionCount(Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > const *self) { + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__Connect(Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *self, void(*func)(Dali::Toolkit::CubeTransitionEffect)) { + self->Connect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__Disconnect(Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *self, void(*func)(Dali::Toolkit::CubeTransitionEffect)) { + self->Disconnect(func); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__Emit(Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *self, Dali::Toolkit::CubeTransitionEffect arg) { + self->Emit(arg); +} + + +#ifdef __cplusplus +extern "C" { +#endif + +// cube-transition-effect.h + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_SWIGUpcast(Dali::Toolkit::CubeTransitionEffect *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CubeTransitionEffect() { + Dali::Toolkit::CubeTransitionEffect* result; + + { + try { + result = new Dali::Toolkit::CubeTransitionEffect(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CubeTransitionEffect(void * jarg1) { + Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; + + arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; + { + try { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_SetTransitionDuration(void * jarg1, float duration) { + Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; + + arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; + { + try { + (arg1)->SetTransitionDuration(duration); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_GetTransitionDuration(void * jarg1) { + Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; + + float result = 0.0f; + arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; + { + try { + result = (arg1)->GetTransitionDuration(); + } + CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_SetCubeDisplacement(void * jarg1, float displacement) { + Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; + + arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; + { + try { + (arg1)->SetCubeDisplacement(displacement); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_GetCubeDisplacement(void * jarg1) { + Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; + + float result = 0.0f; + arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; + { + try { + result = (arg1)->GetCubeDisplacement(); + } + CALL_CATCH_EXCEPTION(0.0f); + } + + return result; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_IsTransitioning(void * jarg1) { + Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; + + bool result = false; + arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; + { + try { + result = (arg1)->IsTransitioning(); + } + CALL_CATCH_EXCEPTION(false); + } + + unsigned int jresult = result; // convert bool to unsigned int. + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_SetCurrentTexture(void* jarg1, void* jarg2) { + Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; + + arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; + Dali::Texture* argp2 = (Dali::Texture*)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0); + return ; + } + + { + try { + (arg1)->SetCurrentTexture(*argp2); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_SetTargetTexture(void* jarg1, void* jarg2) { + Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; + + arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; + Dali::Texture* argp2 = (Dali::Texture*)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0); + return; + } + + { + try { + (arg1)->SetTargetTexture(*argp2); + } + CALL_CATCH_EXCEPTION(); + } +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_StartTransition__SWIG1(void* jarg1, bool toNextImage) { + Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; + + arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; + + { + try { + (arg1)->StartTransition(toNextImage); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_StartTransition__SWIG2(void* jarg1, void* jarg2, void* jarg3) { + Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; + + arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; + + Dali::Vector2* argp2 = (Dali::Vector2*)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); + return; + } + + Dali::Vector2* argp3 = (Dali::Vector2*)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); + return; + } + + { + try { + (arg1)->StartTransition(*argp2, *argp3); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_PauseTransition(void * jarg1) { + Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; + + arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; + { + try { + (arg1)->PauseTransition(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_ResumeTransition(void * jarg1) { + Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; + + arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; + { + try { + (arg1)->ResumeTransition(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_StopTransition(void * jarg1) { + Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; + + arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; + { + try { + (arg1)->StopTransition(); + } + CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_TransitionCompletedSignal(void * jarg1) { + void * jresult; + Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; + Dali::Toolkit::CubeTransitionEffect::TransitionCompletedSignalType *result = 0; + + arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; + { + try { + result = (Dali::Toolkit::CubeTransitionEffect::TransitionCompletedSignalType *) &(arg1)->TransitionCompletedSignal(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CubeTransitionEffectSignal_Empty(void * jarg1) { + unsigned int jresult; + Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *) 0; + bool result; + + arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__Empty((Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > const *)arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_CubeTransitionEffectSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult; + Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *) 0; + std::size_t result; + + arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__GetConnectionCount((Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > const *)arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffectSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *) 0; + void(*arg2)(Dali::Toolkit::CubeTransitionEffect) = (void(*)(Dali::Toolkit::CubeTransitionEffect)) 0; + + arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *)jarg1; + arg2 = (void(*)(Dali::Toolkit::CubeTransitionEffect))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__Connect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffectSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *) 0; + void(*arg2)(Dali::Toolkit::CubeTransitionEffect) = (void(*)(Dali::Toolkit::CubeTransitionEffect)) 0; + + arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *)jarg1; + arg2 = (void(*)(Dali::Toolkit::CubeTransitionEffect))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__Disconnect(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffectSignal_Emit(void * jarg1, void * jarg2) { + Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *) 0; + Dali::Toolkit::CubeTransitionEffect arg2; + Dali::Toolkit::CubeTransitionEffect *argp2; + + arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *)jarg1; + argp2 = (Dali::Toolkit::CubeTransitionEffect *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::CubeTransitionEffect", 0); + return; + } + arg2 = *argp2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__Emit(arg1, arg2); + } + CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CubeTransitionEffectSignal() { + void * jresult; + Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *result = 0; + + { + try { + result = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *)new Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) >(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CubeTransitionEffectSignal(void * jarg1) { + Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *) 0; + + arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *)jarg1; + { + try { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } + +} + + +// cube-transition-cross-effect.h + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_CubeTransitionCrossEffect_SWIGUpcast(Dali::Toolkit::CubeTransitionCrossEffect *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CubeTransitionCrossEffect_New(unsigned int numRows, unsigned int numColumns) { + void * jresult; + Dali::Toolkit::CubeTransitionEffect result; + + { + try { + result = Dali::Toolkit::CubeTransitionCrossEffect::New(numRows, numColumns); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::CubeTransitionCrossEffect((const Dali::Toolkit::CubeTransitionCrossEffect &)result); + + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CubeTransitionCrossEffect(void * jarg1) { + Dali::Toolkit::CubeTransitionCrossEffect *arg1 = (Dali::Toolkit::CubeTransitionCrossEffect *) 0; + + arg1 = (Dali::Toolkit::CubeTransitionCrossEffect *)jarg1; + { + try { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } +} + +// cube-transition-fold-effect.h + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_CubeTransitionFoldEffect_SWIGUpcast(Dali::Toolkit::CubeTransitionFoldEffect *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CubeTransitionFoldEffect_New(unsigned int numRows, unsigned int numColumns) { + void * jresult; + Dali::Toolkit::CubeTransitionEffect result; + + { + try { + result = Dali::Toolkit::CubeTransitionFoldEffect::New(numRows, numColumns); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::CubeTransitionFoldEffect((const Dali::Toolkit::CubeTransitionFoldEffect &)result); + + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CubeTransitionFoldEffect(void * jarg1) { + Dali::Toolkit::CubeTransitionFoldEffect *arg1 = (Dali::Toolkit::CubeTransitionFoldEffect *) 0; + + arg1 = (Dali::Toolkit::CubeTransitionFoldEffect *)jarg1; + { + try { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } +} + +// cube-transition-wave-effect.h + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_CubeTransitionWaveEffect_SWIGUpcast(Dali::Toolkit::CubeTransitionWaveEffect *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CubeTransitionWaveEffect_New(unsigned int numRows, unsigned int numColumns) { + void * jresult; + Dali::Toolkit::CubeTransitionEffect result; + + { + try { + result = Dali::Toolkit::CubeTransitionWaveEffect::New(numRows, numColumns); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::CubeTransitionWaveEffect((const Dali::Toolkit::CubeTransitionWaveEffect &)result); + + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CubeTransitionWaveEffect(void * jarg1) { + Dali::Toolkit::CubeTransitionWaveEffect *arg1 = (Dali::Toolkit::CubeTransitionWaveEffect *) 0; + + arg1 = (Dali::Toolkit::CubeTransitionWaveEffect *)jarg1; + { + try { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } +} + + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/transition-set-wrap.cpp b/dali-csharp-binder/dali-toolkit/transition-set-wrap.cpp new file mode 100755 index 00000000..682d78bc --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/transition-set-wrap.cpp @@ -0,0 +1,280 @@ +/* + * Copyright (c) 2021 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +SWIGINTERN bool Dali_TransitionSet_Signal_Empty(Dali::Toolkit::TransitionSet::TransitionSetSignalType const *self) +{ + return self->Empty(); +} + +SWIGINTERN std::size_t Dali_TransitionSet_Signal_GetConnectionCount(Dali::Toolkit::TransitionSet::TransitionSetSignalType const *self) +{ + return self->GetConnectionCount(); +} + +SWIGINTERN void Dali_TransitionSet_Signal_Connect(Dali::Toolkit::TransitionSet::TransitionSetSignalType *self, void (*func)(Dali::Toolkit::TransitionSet &)) +{ + self->Connect(func); +} + +SWIGINTERN void Dali_TransitionSet_Signal_Disconnect(Dali::Toolkit::TransitionSet::TransitionSetSignalType *self, void (*func)(Dali::Toolkit::TransitionSet &)) +{ + self->Disconnect(func); +} + +#ifdef __cplusplus +extern "C" +{ +#endif + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_TransitionSet() + { + void *jresult; + Dali::Toolkit::TransitionSet *result = 0; + { + try + { + result = (Dali::Toolkit::TransitionSet *)new Dali::Toolkit::TransitionSet(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_TransitionSet_New() + { + void *jresult; + Dali::Toolkit::TransitionSet result; + { + try + { + result = Dali::Toolkit::TransitionSet::New(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::TransitionSet((const Dali::Toolkit::TransitionSet &)result); + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionSet(void *nuiTransitionSet) + { + Dali::Toolkit::TransitionSet *transition = (Dali::Toolkit::TransitionSet *)0; + + transition = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; + { + try + { + delete transition; + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_TransitionSet_Set(void *nuiTransitionSet) + { + Dali::Toolkit::TransitionSet *newTransitionSet = 0; + Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; + if (!transitionSet) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionSet const & type is null", 0); + return 0; + } + { + try + { + newTransitionSet = (Dali::Toolkit::TransitionSet *)new Dali::Toolkit::TransitionSet((Dali::Toolkit::TransitionSet const &)*transitionSet); + } + CALL_CATCH_EXCEPTION(0); + } + void *result; + result = (void *)newTransitionSet; + return result; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_TransitionSet_Assign(void *nuiDestination, void *nuiSource) + { + void *jresult; + Dali::Toolkit::TransitionSet *destination = (Dali::Toolkit::TransitionSet *)0; + Dali::Toolkit::TransitionSet *source = 0; + Dali::Toolkit::TransitionSet *result = 0; + + destination = (Dali::Toolkit::TransitionSet *)nuiDestination; + source = (Dali::Toolkit::TransitionSet *)nuiSource; + + if (!source) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionSet const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Toolkit::TransitionSet *)&(destination)->operator=((Dali::Toolkit::TransitionSet const &)*source); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TransitionSet_AddTransition(void *nuiTransitionSet, void *nuiTransition) + { + Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; + Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransition; + + if (!transitionSet || !transition) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); + return; + } + { + try + { + (transitionSet)->AddTransition(*transition); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_TransitionSet_GetTransitionAt(void *nuiTransitionSet, unsigned int index) + { + Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; + Dali::Toolkit::TransitionBase transition; + { + try + { + transition = (transitionSet)->GetTransitionAt(index); + } + CALL_CATCH_EXCEPTION(0); + } + Dali::Toolkit::TransitionBase *result = new Dali::Toolkit::TransitionBase((const Dali::Toolkit::TransitionBase &)transition); + return result; + } + + SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TransitionSet_GetTransitionCount(void *nuiTransitionSet) + { + Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; + unsigned int result; + { + try + { + result = (unsigned int)((Dali::Toolkit::TransitionSet const *)transitionSet)->GetTransitionCount(); + } + CALL_CATCH_EXCEPTION(0); + } + return result; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TransitionSet_Play(void *nuiTransitionSet) + { + Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; + + if (!transitionSet) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); + return; + } + { + try + { + (transitionSet)->Play(); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_TransitionSet_FinishedSignal(void *nuiTransitionSet) + { + Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; + Dali::Toolkit::TransitionSet::TransitionSetSignalType *transitionSetSignalType = 0; + { + try + { + transitionSetSignalType = (Dali::Toolkit::TransitionSet::TransitionSetSignalType *)&(transitionSet)->FinishedSignal(); + } + CALL_CATCH_EXCEPTION(0); + } + void *result = (void *)transitionSetSignalType; + return result; + } + + SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TransitionSet_Signal_Empty(void *nuiTransitionSet) + { + Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; + bool reselt; + { + try + { + reselt = Dali_TransitionSet_Signal_Empty((Dali::Toolkit::TransitionSet::TransitionSetSignalType const *)transitionSet); + } + CALL_CATCH_EXCEPTION(0); + } + return reselt; + } + + SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TransitionSet_Signal_GetConnectionCount(void *nuiTransitionSet) + { + Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; + std::size_t reselt; + { + try + { + reselt = Dali_TransitionSet_Signal_GetConnectionCount((Dali::Toolkit::TransitionSet::TransitionSetSignalType const *)transitionSet); + } + CALL_CATCH_EXCEPTION(0); + } + return reselt; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TransitionSet_Signal_Connect(void *nuiTransitionSet, void *nuiFunc) + { + Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; + void (*func)(Dali::Toolkit::TransitionSet &) = (void (*)(Dali::Toolkit::TransitionSet &))nuiFunc; + { + try + { + Dali_TransitionSet_Signal_Connect((Dali::Toolkit::TransitionSet::TransitionSetSignalType *)transitionSet, func); + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TransitionSet_Signal_Disconnect(void *nuiTransitionSet, void *nuiFunc) + { + Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; + void (*func)(Dali::Toolkit::TransitionSet &) = (void (*)(Dali::Toolkit::TransitionSet &))nuiFunc; + { + try + { + Dali_TransitionSet_Signal_Disconnect((Dali::Toolkit::TransitionSet::TransitionSetSignalType *)transitionSet, func); + } + CALL_CATCH_EXCEPTION(); + } + } + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/transition-wrap.cpp b/dali-csharp-binder/dali-toolkit/transition-wrap.cpp new file mode 100755 index 00000000..47e984b5 --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/transition-wrap.cpp @@ -0,0 +1,131 @@ +/* + * Copyright (c) 2021 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. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_Transition() + { + void *jresult; + Dali::Toolkit::Transition *result = 0; + + { + try + { + result = (Dali::Toolkit::Transition *)new Dali::Toolkit::Transition(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Transition_New(void *nuiSource, void *nuiDestination, bool useDestinationTarget, void *nuiTimePeriod) + { + void *jresult; + Dali::Toolkit::Control *source = (Dali::Toolkit::Control *)nuiSource; + Dali::Toolkit::Control *destination = (Dali::Toolkit::Control *)nuiDestination; + Dali::TimePeriod *timePeriod = (Dali::TimePeriod *)nuiTimePeriod; + + Dali::Toolkit::Transition result; + + { + try + { + result = Dali::Toolkit::Transition::New(*source, *destination, useDestinationTarget, *timePeriod); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::Toolkit::Transition((const Dali::Toolkit::Transition &)result); + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Transition(void *nuiTransition) + { + Dali::Toolkit::Transition *transition = (Dali::Toolkit::Transition *)0; + + transition = (Dali::Toolkit::Transition *)nuiTransition; + { + try + { + delete transition; + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_Transition_Set(void *nuiTransition) + { + Dali::Toolkit::Transition *newTransition = 0; + Dali::Toolkit::Transition *transition = (Dali::Toolkit::Transition *)nuiTransition; + if (!transition) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Transition const & type is null", 0); + return 0; + } + { + try + { + newTransition = (Dali::Toolkit::Transition *)new Dali::Toolkit::Transition((Dali::Toolkit::Transition const &)*transition); + } + CALL_CATCH_EXCEPTION(0); + } + void *result; + result = (void *)newTransition; + return result; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Transition_Assign(void *nuiDestination, void *nuiSource) + { + void *jresult; + Dali::Toolkit::Transition *destination = (Dali::Toolkit::Transition *)0; + Dali::Toolkit::Transition *source = 0; + Dali::Toolkit::Transition *result = 0; + + destination = (Dali::Toolkit::Transition *)nuiDestination; + source = (Dali::Toolkit::Transition *)nuiSource; + + if (!source) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Transition const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::Toolkit::Transition *)&(destination)->operator=((Dali::Toolkit::Transition const &)*source); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/visual-actions-wrap.cpp b/dali-csharp-binder/dali-toolkit/visual-actions-wrap.cpp new file mode 100644 index 00000000..940cdb38 --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/visual-actions-wrap.cpp @@ -0,0 +1,107 @@ +/* + * Copyright (c) 2023 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + // Visual common action + SWIGEXPORT int SWIGSTDCALL CSharp_Visual_Actions_UPDATE_PROPERTY_get() + { + return (int)Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY; + } + + // Image Visual action + SWIGEXPORT int SWIGSTDCALL CSharp_ImageVisual_Actions_RELOAD_get() + { + return (int)Dali::Toolkit::DevelImageVisual::Action::RELOAD; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_ImageVisual_Actions_PLAY_get() + { + return (int)Dali::Toolkit::DevelAnimatedImageVisual::Action::PLAY; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_ImageVisual_Actions_PAUSE_get() + { + return (int)Dali::Toolkit::DevelAnimatedImageVisual::Action::PAUSE; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_ImageVisual_Actions_STOP_get() + { + return (int)Dali::Toolkit::DevelAnimatedImageVisual::Action::STOP; + } + + // Animated Image Visual action + SWIGEXPORT int SWIGSTDCALL CSharp_AnimatedImageVisual_Actions_PLAY_get() + { + return (int)Dali::Toolkit::DevelAnimatedImageVisual::Action::PLAY; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_AnimatedImageVisual_Actions_PAUSE_get() + { + return (int)Dali::Toolkit::DevelAnimatedImageVisual::Action::PAUSE; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_AnimatedImageVisual_Actions_STOP_get() + { + return (int)Dali::Toolkit::DevelAnimatedImageVisual::Action::STOP; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_AnimatedImageVisual_Actions_JUMP_TO_get() + { + return (int)Dali::Toolkit::DevelAnimatedImageVisual::Action::JUMP_TO; + } + + // Animated Vector Image Visual action + SWIGEXPORT int SWIGSTDCALL CSharp_AnimatedVectorImageVisual_Actions_PLAY_get() + { + return (int)Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_AnimatedVectorImageVisual_Actions_PAUSE_get() + { + return (int)Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PAUSE; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_AnimatedVectorImageVisual_Actions_STOP_get() + { + return (int)Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::STOP; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_AnimatedVectorImageVisual_Actions_JUMP_TO_get() + { + return (int)Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::JUMP_TO; + } + + SWIGEXPORT int SWIGSTDCALL CSharp_AnimatedVectorImageVisual_Actions_SET_DYNAMIC_PROPERTY_get() + { + return (int)Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::SET_DYNAMIC_PROPERTY; + } +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/dali-toolkit/web-view-wrap.cpp b/dali-csharp-binder/dali-toolkit/web-view-wrap.cpp new file mode 100755 index 00000000..bf724202 --- /dev/null +++ b/dali-csharp-binder/dali-toolkit/web-view-wrap.cpp @@ -0,0 +1,3721 @@ +/* + * Copyright (c) 2022 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// INTERNAL INCLUDES +#include + +/* Callback for returning strings to C# without leaking memory */ +using SWIG_CSharpStringHelperCallback = char* (SWIGSTDCALL*)(const char*); +extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; + +#ifdef __cplusplus +extern "C" { +#endif + +//----------------------------------WebView--------------------------------------------------- +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() { + void * jresult; + Dali::Toolkit::WebView result; + + { + try { + result = Dali::Toolkit::WebView::New(); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView&)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) { + void * jresult; + Dali::Toolkit::WebView result; + + std::string *arg1; + std::string *arg2; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0); + return 0; + } + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); + return 0; + } + + std::string jarg1_str = std::string(jarg1); + std::string jarg2_str = std::string(jarg2); + + arg1 = &jarg1_str; + arg2 = &jarg2_str; + + { + try { + result = Dali::Toolkit::WebView::New((std::string const &)*arg1, (std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView&)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_3(uint32_t jarg1, char ** jarg2) { + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); + return 0; + } + + Dali::Toolkit::WebView result; + { + try { + result = Dali::Toolkit::WebView::New(jarg1, jarg2); + } CALL_CATCH_EXCEPTION(0); + } + void * jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_GetContext() { + void * jresult; + Dali::WebEngineContext *result = 0; + + { + try { + result = Dali::Toolkit::WebView::GetContext(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_GetCookieManager() { + void * jresult; + Dali::WebEngineCookieManager *result = 0; + + { + try { + result = Dali::Toolkit::WebView::GetCookieManager(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) { + void * jresult; + Dali::Toolkit::WebView* arg1 = 0; + Dali::Toolkit::WebView* result = 0; + + arg1 = (Dali::Toolkit::WebView*)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::WebView*)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; + arg1 = (Dali::Toolkit::WebView*)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) { + void * jresult; + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; + Dali::Toolkit::WebView* arg2 = 0; + Dali::Toolkit::WebView* result = 0; + + arg1 = (Dali::Toolkit::WebView*)jarg1; + arg2 = (Dali::Toolkit::WebView*)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::Toolkit::WebView*)&(arg1)->operator=((Dali::Toolkit::WebView const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) { + void * jresult; + Dali::BaseHandle arg1; + Dali::BaseHandle* argp1; + Dali::Toolkit::WebView 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::WebView::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView&)result); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_GetBackForwardList(void * jarg1) { + void * jresult; + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; + Dali::Toolkit::WebBackForwardList *result = 0; + + arg1 = (Dali::Toolkit::WebView*)jarg1; + + { + try { + result = arg1->GetBackForwardList(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_GetSettings(void * jarg1) { + void * jresult; + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; + Dali::Toolkit::WebSettings *result = 0; + + arg1 = (Dali::Toolkit::WebView*)jarg1; + + { + try { + result = arg1->GetSettings(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() { + return (int)Dali::Toolkit::WebView::Property::URL; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_SCROLL_POSITION_get() { + return (int)Dali::Toolkit::WebView::Property::SCROLL_POSITION; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_SCROLL_SIZE_get() { + return (int)Dali::Toolkit::WebView::Property::SCROLL_SIZE; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CONTENT_SIZE_get() { + return (int)Dali::Toolkit::WebView::Property::CONTENT_SIZE; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_TITLE_get() { + return (int)Dali::Toolkit::WebView::Property::TITLE; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_VIDEO_HOLE_ENABLED_get() { + return (int)Dali::Toolkit::WebView::Property::VIDEO_HOLE_ENABLED; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_MOUSE_EVENTS_ENABLED_get() { + return (int) Dali::Toolkit::WebView::Property::MOUSE_EVENTS_ENABLED; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_KEY_EVENTS_ENABLED_get() { + return (int) Dali::Toolkit::WebView::Property::KEY_EVENTS_ENABLED; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DOCUMENT_BACKGROUND_COLOR_get() { + return (int)Dali::Toolkit::WebView::Property::DOCUMENT_BACKGROUND_COLOR; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_TILES_CLEARED_WHEN_HIDDEN_get() { + return (int)Dali::Toolkit::WebView::Property::TILES_CLEARED_WHEN_HIDDEN; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_TILE_COVER_AREA_MULTIPLIER_get() { + return (int)Dali::Toolkit::WebView::Property::TILE_COVER_AREA_MULTIPLIER; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CURSOR_ENABLED_BY_CLIENT_get() { + return (int)Dali::Toolkit::WebView::Property::CURSOR_ENABLED_BY_CLIENT; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_SELECTED_TEXT_get() { + return (int)Dali::Toolkit::WebView::Property::SELECTED_TEXT; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_PAGE_ZOOM_FACTOR_get() { + return (int)Dali::Toolkit::WebView::Property::PAGE_ZOOM_FACTOR; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_TEXT_ZOOM_FACTOR_get() { + return (int)Dali::Toolkit::WebView::Property::TEXT_ZOOM_FACTOR; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_PROGRESS_PERCENTAGE_get() { + return (int)Dali::Toolkit::WebView::Property::LOAD_PROGRESS_PERCENTAGE; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() { + return (int)Dali::Toolkit::WebView::Property::USER_AGENT; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; + std::string *arg2; + + arg1 = (Dali::Toolkit::WebView*)jarg1; + + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return; + } + + std::string jarg2str = std::string(jarg2); + arg2 = &jarg2str; + { + try { + (arg1)->LoadUrl((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHtmlString(void * jarg1, char * jarg2) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; + std::string *arg2; + + arg1 = (Dali::Toolkit::WebView*)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return; + } + std::string jarg2str = std::string(jarg2); + arg2 = &jarg2str; + { + try { + (arg1)->LoadHtmlString((std::string const &)*arg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_LoadHtmlStringOverrideCurrentEntry(void * jarg1, const char *jarg2, const char *jarg3, const char *jarg4) { + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return false; + } + + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + std::string jarg2str = std::string(jarg2); + std::string jarg3str = jarg3 ? std::string(jarg3) : std::string(); + std::string jarg4str = jarg4 ? std::string(jarg4) : std::string(); + bool result = false; + { + try { + result = (arg1)->LoadHtmlStringOverrideCurrentEntry(jarg2str, jarg3str, jarg4str); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_LoadContents(void * jarg1, const int8_t *jarg2, uint32_t jarg3, const char *jarg4, const char *jarg5, const char *jarg6) { + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return false; + } + + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + std::string jarg4str = jarg4 ? std::string(jarg4) : std::string(); + std::string jarg5str = jarg5 ? std::string(jarg5) : std::string(); + std::string jarg6str = jarg6 ? std::string(jarg6) : std::string(); + bool result = false; + { + try { + result = (arg1)->LoadContents(jarg2, jarg3, jarg4str, jarg5str, jarg6str); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT const void * SWIGSTDCALL CSharp_Dali_WebView_GetFavicon(void * jarg1) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)jarg1; + Dali::Toolkit::ImageView* result = 0; + { + try { + Dali::Toolkit::ImageView favicon = (arg1)->GetFavicon(); + if (favicon) + { + result = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)favicon); + } + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; + + arg1 = (Dali::Toolkit::WebView*)jarg1; + { + try { + (arg1)->Reload(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_ReloadWithoutCache(void * jarg1) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + bool result = false; + { + try { + result = (arg1)->ReloadWithoutCache(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; + + arg1 = (Dali::Toolkit::WebView*)jarg1; + { + try { + (arg1)->StopLoading(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; + + arg1 = (Dali::Toolkit::WebView*)jarg1; + { + try { + (arg1)->Suspend(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; + + arg1 = (Dali::Toolkit::WebView*)jarg1; + { + try { + (arg1)->Resume(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_SuspendNetworkLoading(void * jarg1) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + { + try { + (arg1)->SuspendNetworkLoading(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ResumeNetworkLoading(void * jarg1) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + { + try { + (arg1)->ResumeNetworkLoading(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_AddCustomHeader(void * jarg1, const char *jarg2, const char *jarg3) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + std::string jarg2str = std::string(jarg2); + std::string jarg3str = std::string(jarg3); + bool result = false; + { + try { + result = (arg1)->AddCustomHeader(jarg2str, jarg3str); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_RemoveCustomHeader(void * jarg1, const char *jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + std::string jarg2str = std::string(jarg2); + bool result = false; + { + try { + result = (arg1)->RemoveCustomHeader(jarg2str); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebView_StartInspectorServer(void * jarg1, uint32_t jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + uint32_t result = 0; + { + try { + result = (arg1)->StartInspectorServer(jarg2); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_StopInspectorServer(void * jarg1) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + bool result = false; + { + try { + result = (arg1)->StopInspectorServer(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ScrollBy(void * jarg1, int32_t jarg2, int32_t jarg3) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; + arg1 = (Dali::Toolkit::WebView*)jarg1; + { + try { + (arg1)->ScrollBy(jarg2, jarg3); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_ScrollEdgeBy(void * jarg1, int32_t jarg2, int32_t jarg3) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + bool result = false; + { + try { + result = (arg1)->ScrollEdgeBy(jarg2, jarg3); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; + + arg1 = (Dali::Toolkit::WebView*)jarg1; + { + try { + (arg1)->GoBack(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; + + arg1 = (Dali::Toolkit::WebView*)jarg1; + { + try { + (arg1)->GoForward(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; + bool ret; + + arg1 = (Dali::Toolkit::WebView*)jarg1; + { + try { + ret = (arg1)->CanGoBack(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; + bool ret; + + arg1 = (Dali::Toolkit::WebView*)jarg1; + { + try { + ret = (arg1)->CanGoForward(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void * jarg3) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; + std::string *arg2; + + arg1 = (Dali::Toolkit::WebView*)jarg1; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return; + } + std::string jarg2_str = std::string(jarg2); + arg2 = &jarg2_str; + + { + try { + if (jarg3) { + void (*handler)(char *) = (void (*)(char *))jarg3; + (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string &result) { + handler(SWIG_csharp_string_callback(result.c_str())); + }); + } + else { + (arg1)->EvaluateJavaScript((std::string const &)*arg2); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void * jarg1, char * jarg2, void * jarg3) { + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return; + } + + Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1; + std::string exposedObjectName = jarg2; + void (*handler)(char*) = (void (*)(char*))jarg3; + + { + try { + webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string &message) { + handler(SWIG_csharp_string_callback(message.c_str())); + }); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterJavaScriptAlertCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1; + bool (*handler)(char*) = (bool (*)(char*))jarg2; + { + try { + if (handler) + { + webview->RegisterJavaScriptAlertCallback([handler](const std::string &message) -> bool { + return handler(SWIG_csharp_string_callback(message.c_str())); + }); + } + else + { + webview->RegisterJavaScriptAlertCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_JavaScriptAlertReply(void * jarg1) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)jarg1; + { + try { + (arg1)->JavaScriptAlertReply(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterJavaScriptConfirmCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1; + bool (*handler)(char*) = (bool (*)(char*))jarg2; + + { + try { + if (handler) + { + webview->RegisterJavaScriptConfirmCallback([handler](const std::string &message) -> bool { + return handler(SWIG_csharp_string_callback(message.c_str())); + }); + } + else + { + webview->RegisterJavaScriptConfirmCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_JavaScriptConfirmReply(void * jarg1, bool jarg2) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)jarg1; + { + try { + (arg1)->JavaScriptConfirmReply(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterJavaScriptPromptCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1; + bool (*handler)(char *, char*) = (bool (*)(char *, char*))jarg2; + + { + try { + if (handler) + { + webview->RegisterJavaScriptPromptCallback([handler](const std::string &message1, + const std::string &message2) -> bool { + return handler(SWIG_csharp_string_callback(message1.c_str()), + SWIG_csharp_string_callback(message2.c_str())); + }); + } + else + { + webview->RegisterJavaScriptPromptCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_JavaScriptPromptReply(void * jarg1, char * jarg2) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)jarg1; + std::string jarg2str = std::string(jarg2); + { + try { + (arg1)->JavaScriptPromptReply(jarg2str); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WebView_CreateHitTest(void * jarg1, int32_t jarg2, int32_t jarg3, int jarg4) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)jarg1; + Dali::WebEngineHitTest* result = 0; + { + try { + std::unique_ptr hitTest = (arg1)->CreateHitTest(jarg2, jarg3, (Dali::WebEngineHitTest::HitTestMode)jarg4); + result = hitTest.release(); + } CALL_CATCH_EXCEPTION(0); + } + return (void *)result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CreateHitTestAsynchronously(void * jarg1, int32_t jarg2, int32_t jarg3, int jarg4, void * jarg5) { + Dali::Toolkit::WebView *webview = (Dali::Toolkit::WebView *)jarg1; + bool (*handler)(Dali::WebEngineHitTest*) = (bool (*)(Dali::WebEngineHitTest*))jarg5; + bool result = false; + { + try { + result = webview->CreateHitTestAsynchronously(jarg2, jarg3, (Dali::WebEngineHitTest::HitTestMode)jarg4, + [handler](std::unique_ptr hitTest) -> bool { + return handler(hitTest.release()); + }); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; + + arg1 = (Dali::Toolkit::WebView*)jarg1; + { + try { + (arg1)->ClearHistory(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearAllTilesResources(void * jarg1) { + Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)jarg1; + { + try { + (arg1)->ClearAllTilesResources(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_SetScaleFactor(void * jarg1, float jarg2, void * jarg3) { + if (!jarg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 is null", 0); + return; + } + + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + Dali::Vector2 *arg3 = (Dali::Vector2 *)jarg3; + { + try { + (arg1)->SetScaleFactor(jarg2, *arg3); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WebView_GetScaleFactor(void * jarg1) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + float result = 0.0f; + { + try { + result = (arg1)->GetScaleFactor(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ActivateAccessibility(void * jarg1, bool jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + { + try { + (arg1)->ActivateAccessibility(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_HighlightText(void * jarg1, const char *jarg2, int jarg3, uint32_t jarg4) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + std::string jarg2str = std::string(jarg2); + bool result = false; + { + try { + result = (arg1)->HighlightText( + jarg2str, (Dali::WebEnginePlugin::FindOption)jarg3, jarg4); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddDynamicCertificatePath(void * jarg1, const char *jarg2, const char *jarg3) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + std::string jarg2str = std::string(jarg2); + std::string jarg3str = std::string(jarg3); + { + try { + (arg1)->AddDynamicCertificatePath(jarg2str, jarg3str); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WebView_GetScreenshot(void * jarg1, void * jarg2, float jarg3) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + Dali::Rect *arg = (Dali::Rect *)jarg2; + Dali::Toolkit::ImageView* result = 0; + { + try { + Dali::Toolkit::ImageView screenshot = (arg1)->GetScreenshot(*arg, jarg3); + if (screenshot) + { + result = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)screenshot); + } + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +using SWIG_CallbackWebViewScreenshotCaptured = void(SWIGSTDCALL *)(Dali::Toolkit::ImageView *); +SWIG_CallbackWebViewScreenshotCaptured swig_callbackOnWebViewScreenshotCaptured; + +void OnWebViewScreenshotCapturedCallback(Dali::Toolkit::ImageView imageView) { + if (!imageView) + return; + + Dali::Toolkit::ImageView* pImageView = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)imageView); + swig_callbackOnWebViewScreenshotCaptured(pImageView); +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_GetScreenshotAsynchronously(void * jarg1, void * jarg2, float jarg3, void * jarg4) { + swig_callbackOnWebViewScreenshotCaptured = (SWIG_CallbackWebViewScreenshotCaptured)jarg4; + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + Dali::Rect *arg2 = (Dali::Rect *)jarg2; + Dali::Toolkit::WebView::WebViewScreenshotCapturedCallback callback = OnWebViewScreenshotCapturedCallback; + bool result; + { + try { + result = (arg1)->GetScreenshotAsynchronously(*arg2, jarg3, callback); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CheckVideoPlayingAsynchronously(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + void (*handler)(bool) = (void (*)(bool))jarg2; + bool result; + { + try { + result = (arg1)->CheckVideoPlayingAsynchronously([handler](bool isPlaying) { handler(isPlaying); }); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterGeolocationPermissionCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + bool (*handler)(char *, char *) = (bool (*)(char *, char *))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterGeolocationPermissionCallback([handler](const std::string &host, const std::string &protocol) -> bool { + return handler(SWIG_csharp_string_callback(host.c_str()), + SWIG_csharp_string_callback(protocol.c_str())); + }); + } + else + { + (arg1)->RegisterGeolocationPermissionCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_SetTtsFocus(void* jarg1, bool jarg2) { + Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1; + try { + webview->SetTtsFocus(jarg2); + } CALL_CATCH_EXCEPTION(); +} + +SWIGEXPORT Dali::Toolkit::Control *SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView* jarg1) { + return (Dali::Toolkit::Control*)jarg1; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterPageLoadStartedCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + void (*handler)(char*) = (void (*)(char*))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterPageLoadStartedCallback([handler](const std::string& url) { + handler(SWIG_csharp_string_callback(url.c_str())); + }); + } + else + { + (arg1)->RegisterPageLoadStartedCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterPageLoadInProgressCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + void (*handler)(char*) = (void (*)(char*))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterPageLoadInProgressCallback([handler](const std::string& url) { + handler(SWIG_csharp_string_callback(url.c_str())); + }); + } + else + { + (arg1)->RegisterPageLoadInProgressCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterPageLoadFinishedCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + void (*handler)(char*) = (void (*)(char*))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterPageLoadFinishedCallback([handler](const std::string& url) { + handler(SWIG_csharp_string_callback(url.c_str())); + }); + } + else + { + (arg1)->RegisterPageLoadFinishedCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterPageLoadErrorCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + void (*handler)(Dali::WebEngineLoadError*) = (void (*)(Dali::WebEngineLoadError*))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterPageLoadErrorCallback([handler](std::unique_ptr error) { + handler(error.release()); + }); + } + else + { + (arg1)->RegisterPageLoadErrorCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterScrollEdgeReachedCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + void (*handler)(int) = (void (*)(int))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterScrollEdgeReachedCallback([handler](Dali::WebEnginePlugin::ScrollEdge edge) { + handler((int)edge); + }); + } + else + { + (arg1)->RegisterScrollEdgeReachedCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterUrlChangedCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + void (*handler)(char*) = (void (*)(char*))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterUrlChangedCallback([handler](const std::string& url) { + handler(SWIG_csharp_string_callback(url.c_str())); + }); + } + else + { + (arg1)->RegisterUrlChangedCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterFormRepostDecidedCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + void (*handler)(Dali::WebEngineFormRepostDecision*) = (void (*)(Dali::WebEngineFormRepostDecision*))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterFormRepostDecidedCallback([handler](std::unique_ptr decision) { + handler(decision.release()); + }); + } + else + { + (arg1)->RegisterFormRepostDecidedCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterFrameRenderedCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + void (*handler)(void) = (void (*)(void))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterFrameRenderedCallback([handler](void) { + handler(); + }); + } + else + { + (arg1)->RegisterFrameRenderedCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterConsoleMessageReceivedCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + void (*handler)(Dali::WebEngineConsoleMessage*) = (void (*)(Dali::WebEngineConsoleMessage*))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterConsoleMessageReceivedCallback([handler](std::unique_ptr message) { + handler(message.release()); + }); + } + else + { + (arg1)->RegisterConsoleMessageReceivedCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterResponsePolicyDecidedCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + void (*handler)(Dali::WebEnginePolicyDecision*) = (void (*)(Dali::WebEnginePolicyDecision*))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterResponsePolicyDecidedCallback([handler](std::unique_ptr decision) { + handler(decision.release()); + }); + } + else + { + (arg1)->RegisterResponsePolicyDecidedCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterNavigationPolicyDecidedCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + void (*handler)(Dali::WebEnginePolicyDecision*) = (void (*)(Dali::WebEnginePolicyDecision*))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterNavigationPolicyDecidedCallback([handler](std::unique_ptr decision) { + handler(decision.release()); + }); + } + else + { + (arg1)->RegisterNavigationPolicyDecidedCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterNewWindowCreatedCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + void (*handler)(Dali::Toolkit::WebView*&) = (void (*)(Dali::Toolkit::WebView*&))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterNewWindowCreatedCallback([handler](Dali::WebEnginePlugin*& plugin) { + Dali::Toolkit::WebView* outView = nullptr; + handler(outView); + if (outView != nullptr) + { + plugin = outView->GetPlugin(); + } + }); + } + else + { + (arg1)->RegisterNewWindowCreatedCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterCertificateConfirmedCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + void (*handler)(Dali::WebEngineCertificate*) = (void (*)(Dali::WebEngineCertificate*))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterCertificateConfirmedCallback([handler](std::unique_ptr certificate) { + handler(certificate.release()); + }); + } + else + { + (arg1)->RegisterCertificateConfirmedCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterSslCertificateChangedCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + void (*handler)(Dali::WebEngineCertificate*) = (void (*)(Dali::WebEngineCertificate*))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterSslCertificateChangedCallback([handler](std::unique_ptr certificate) { + handler(certificate.release()); + }); + } + else + { + (arg1)->RegisterSslCertificateChangedCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterHttpAuthHandlerCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + void (*handler)(Dali::WebEngineHttpAuthHandler*) = (void (*)(Dali::WebEngineHttpAuthHandler*))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterHttpAuthHandlerCallback([handler](std::unique_ptr certificate) { + handler(certificate.release()); + }); + } + else + { + (arg1)->RegisterHttpAuthHandlerCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterContextMenuShownCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + void (*handler)(Dali::WebEngineContextMenu*) = (void (*)(Dali::WebEngineContextMenu*))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterContextMenuShownCallback([handler](std::unique_ptr menu) { + handler(menu.release()); + }); + } + else + { + (arg1)->RegisterContextMenuShownCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterContextMenuHiddenCallback(void * jarg1, void * jarg2) { + Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; + void (*handler)(Dali::WebEngineContextMenu*) = (void (*)(Dali::WebEngineContextMenu*))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterContextMenuHiddenCallback([handler](std::unique_ptr menu) { + handler(menu.release()); + }); + } + else + { + (arg1)->RegisterContextMenuHiddenCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GetPlainTextAsynchronously(void * nuiWebView, void * nuiCallback) { + Dali::Toolkit::WebView *webview = (Dali::Toolkit::WebView *)nuiWebView; + void (*callback)(char*) = (void (*)(char*))nuiCallback; + { + try { + webview->GetPlainTextAsynchronously([callback](const std::string& url) { + callback(SWIG_csharp_string_callback(url.c_str())); + }); + } CALL_CATCH_EXCEPTION(); + } +} + +//----------------------------------WebBackForwardListItem----------------------------------------------------- +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebBackForwardListItem_GetUrl(void * jarg1) { + Dali::WebEngineBackForwardListItem *arg1 = (Dali::WebEngineBackForwardListItem *)0; + std::string result; + arg1 = (Dali::WebEngineBackForwardListItem *)jarg1; + { + try { + result = arg1->GetUrl(); + } CALL_CATCH_EXCEPTION(0); + } + char * jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebBackForwardListItem_GetTitle(void * jarg1) { + Dali::WebEngineBackForwardListItem *arg1 = (Dali::WebEngineBackForwardListItem *)0; + std::string result; + arg1 = (Dali::WebEngineBackForwardListItem *)jarg1; + { + try { + result = (arg1)->GetTitle(); + } CALL_CATCH_EXCEPTION(0); + } + char * jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebBackForwardListItem_GetOriginalUrl(void * jarg1) { + Dali::WebEngineBackForwardListItem *arg1 = (Dali::WebEngineBackForwardListItem *)0; + std::string result; + arg1 = (Dali::WebEngineBackForwardListItem *)jarg1; + { + try { + result = (arg1)->GetOriginalUrl(); + } CALL_CATCH_EXCEPTION(0); + } + char * jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +//----------------------------------WebBackForwardList----------------------------------------------------- +SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetItemCount(void * jarg1) { + Dali::Toolkit::WebBackForwardList *arg1 = (Dali::Toolkit::WebBackForwardList *)0; + uint32_t result = 0; + arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1; + { + try { + result = (arg1)->GetItemCount(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetCurrentItem(void *jarg1) { + Dali::WebEngineBackForwardListItem *result = 0; + Dali::Toolkit::WebBackForwardList *arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1; + { + try { + std::unique_ptr temp = (arg1)->GetCurrentItem(); + result = temp.release(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetPreviousItem(void* jarg1) { + Dali::WebEngineBackForwardListItem *result = 0; + Dali::Toolkit::WebBackForwardList* arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1; + { + try { + std::unique_ptr temp = (arg1)->GetPreviousItem(); + result = temp.release(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetNextItem(void* jarg1) { + Dali::WebEngineBackForwardListItem *result = 0; + Dali::Toolkit::WebBackForwardList* arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1; + { + try { + std::unique_ptr temp = (arg1)->GetNextItem(); + result = temp.release(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetItemAtIndex(void *jarg1, int jarg2) { + Dali::WebEngineBackForwardListItem *result = 0; + Dali::Toolkit::WebBackForwardList *arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1; + { + try { + std::unique_ptr temp = (arg1)->GetItemAtIndex(jarg2); + result = temp.release(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebBackForwardList_DeleteItem(void *jarg1) { + Dali::WebEngineBackForwardListItem *arg1 = (Dali::WebEngineBackForwardListItem *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetBackwardItems(void *jarg1, int jarg2) { + std::vector> *result = 0; + Dali::Toolkit::WebBackForwardList *arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1; + { + try { + result = new std::vector>(); + std::vector> temp = (arg1)->GetBackwardItems(jarg2); + result->swap(temp); + } CALL_CATCH_EXCEPTION(0); + } + return (void *)result; +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetForwardItems(void *jarg1, int jarg2) { + std::vector> *result = 0; + Dali::Toolkit::WebBackForwardList *arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1; + { + try { + result = new std::vector>(); + std::vector> temp = (arg1)->GetForwardItems(jarg2); + result->swap(temp); + } CALL_CATCH_EXCEPTION(0); + } + return (void *)result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebBackForwardList_DeleteCopiedItems(void *jarg1) { + std::vector> *arg1 = (std::vector> *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetCopiedItemsCount(void *jarg1) { + unsigned int result = 0; + std::vector> *arg1 = (std::vector> *)jarg1; + { + try { + result = (arg1)->size(); + } CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetItemAtIndexFromCopiedItems(void *jarg1, unsigned int jarg2) { + Dali::WebEngineBackForwardListItem *result = 0; + std::vector> *arg1 = (std::vector> *)jarg1; + { + try { + result = (arg1)->operator[](jarg2).get(); + } CALL_CATCH_EXCEPTION(0); + } + return (void *)result; +} + +//----------------------------------WebConsoleMessage----------------------------------------------------- +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebConsoleMessage(void * jarg1) { + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebConsoleMessage is null", 0); + return; + } + + Dali::WebEngineConsoleMessage* arg1 = (Dali::WebEngineConsoleMessage*)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebConsoleMessage_GetSource(void* jarg1) { + Dali::WebEngineConsoleMessage* arg1 = (Dali::WebEngineConsoleMessage*)jarg1; + std::string result; + { + try { + result = arg1->GetSource(); + } CALL_CATCH_EXCEPTION(0); + } + char* jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebConsoleMessage_GetLine(void* jarg1) { + Dali::WebEngineConsoleMessage* arg1 = (Dali::WebEngineConsoleMessage*)jarg1; + uint32_t result; + { + try { + result = arg1->GetLine(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebConsoleMessage_GetSeverityLevel(void* jarg1) { + Dali::WebEngineConsoleMessage* arg1 = (Dali::WebEngineConsoleMessage*)jarg1; + int result; + { + try { + result = (int)arg1->GetSeverityLevel(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebConsoleMessage_GetText(void* jarg1) { + Dali::WebEngineConsoleMessage* arg1 = (Dali::WebEngineConsoleMessage*)jarg1; + std::string result; + { + try { + result = arg1->GetText(); + } CALL_CATCH_EXCEPTION(0); + } + char* jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +//----------------------------------WebCertificate----------------------------------------------------- +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebCertificate(void * jarg1) { + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebCertificate is null", 0); + return; + } + + Dali::WebEngineCertificate* arg1 = (Dali::WebEngineCertificate*)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebCertificate_Allow(void * jarg1, bool jarg2) { + Dali::WebEngineCertificate *arg1 = (Dali::WebEngineCertificate*)jarg1; + { + try { + (arg1)->Allow(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebCertificate_IsFromMainFrame(void * jarg1) { + Dali::WebEngineCertificate* arg1 = (Dali::WebEngineCertificate*)jarg1; + bool ret; + { + try { + ret = (arg1)->IsFromMainFrame(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT const char *SWIGSTDCALL CSharp_Dali_WebCertificate_GetPem(void * jarg1) { + Dali::WebEngineCertificate* arg1 = (Dali::WebEngineCertificate*)jarg1; + std::string result; + { + try { + result = (arg1)->GetPem(); + } CALL_CATCH_EXCEPTION(0); + } + char *jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebCertificate_IsContextSecure(void * jarg1) { + Dali::WebEngineCertificate* arg1 = (Dali::WebEngineCertificate*)jarg1; + bool ret; + { + try { + ret = (arg1)->IsContextSecure(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +//----------------------------------WebContext----------------------------------------------------- +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebContext_GetCacheModel(void * jarg1) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + int ret; + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + ret = (int)(arg1)->GetCacheModel(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetCacheModel(void * jarg1, int jarg2) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + (arg1)->SetCacheModel((Dali::WebEngineContext::CacheModel)jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetProxyUri(void * jarg1, const char * jarg2) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + + arg1 = (Dali::WebEngineContext *)jarg1; + std::string arg2_str(jarg2); + { + try { + (arg1)->SetProxyUri(arg2_str); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebContext_GetProxyUri(void *jarg1) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + char *jresult; + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + const std::string str = (arg1)->GetProxyUri(); + jresult = SWIG_csharp_string_callback(str.c_str()); + } CALL_CATCH_EXCEPTION(0); + } + + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetProxyBypassRule(void *jarg1, char *jarg2, char *jarg3) { + if (!jarg2 || !jarg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return; + } + + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + const std::string arg2(jarg2); + const std::string arg3(jarg3); + + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + (arg1)->SetProxyBypassRule(arg2, arg3); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebContext_GetProxyBypassRule(void *jarg1) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + char *jresult; + + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + const std::string str = (arg1)->GetProxyBypassRule(); + jresult = SWIG_csharp_string_callback(str.c_str()); + } CALL_CATCH_EXCEPTION(0); + } + + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetCertificateFilePath(void * jarg1, const char * jarg2) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + + arg1 = (Dali::WebEngineContext *)jarg1; + std::string arg2_str(jarg2); + { + try { + (arg1)->SetCertificateFilePath(arg2_str); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebContext_GetCertificateFilePath(void *jarg1) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + char *jresult; + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + const std::string str = (arg1)->GetCertificateFilePath(); + jresult = SWIG_csharp_string_callback(str.c_str()); + } CALL_CATCH_EXCEPTION(0); + } + + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetDefaultProxyAuth(void * jarg1, const char * jarg2, const char * jarg3) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; + std::string arg2_str(jarg2); + std::string arg3_str(jarg3); + { + try { + (arg1)->SetDefaultProxyAuth(arg2_str, arg3_str); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_DeleteAllWebDatabase(void *jarg1) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + (arg1)->DeleteAllWebDatabase(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_GetWebDatabaseOrigins(void *jarg1, void *jarg2) { + Dali::WebEngineContext * arg1 = (Dali::WebEngineContext *)jarg1; + void (*handler)(std::vector>*) = (void (*)(std::vector>*))jarg2; + bool result = false; + { + try { + result = (arg1)->GetWebDatabaseOrigins( + [handler](std::vector>& originList) { + std::vector>* webOriginList = new std::vector>(); + webOriginList->swap(originList); + handler(webOriginList); + }); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_DeleteWebDatabase(void *jarg1, void *jarg2) { + Dali::WebEngineContext * arg1 = (Dali::WebEngineContext *)jarg1; + Dali::WebEngineSecurityOrigin * origin = (Dali::WebEngineSecurityOrigin *)jarg2; + bool result = false; + { + try { + result = (arg1)->DeleteWebDatabase(*origin); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_GetWebStorageOrigins(void *jarg1, void *jarg2) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; + void (*handler)(std::vector>*) = (void (*)(std::vector>*))jarg2; + bool result = false; + { + try { + result = (arg1)->GetWebStorageOrigins( + [handler](std::vector>& originList) { + std::vector>* contextOriginList = new std::vector>(); + contextOriginList->swap(originList); + handler(contextOriginList); + }); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_GetWebStorageUsageForOrigin(void *jarg1, void *jarg2, void *jarg3) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; + Dali::WebEngineSecurityOrigin *origin = (Dali::WebEngineSecurityOrigin *)jarg2; + void (*callback)(uint64_t) = (void (*)(uint64_t))jarg3; + bool result = false; + { + try { + result = (arg1)->GetWebStorageUsageForOrigin(*origin, callback); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_DeleteAllWebStorage(void *jarg1) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + (arg1)->DeleteAllWebStorage(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_DeleteWebStorage(void *jarg1, void *jarg2) { + Dali::WebEngineContext * arg1 = (Dali::WebEngineContext *)jarg1; + Dali::WebEngineSecurityOrigin * origin = (Dali::WebEngineSecurityOrigin *)jarg2; + bool result = false; + { + try { + result = (arg1)->DeleteWebStorage(*origin); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_DeleteLocalFileSystem(void *jarg1) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + (arg1)->DeleteLocalFileSystem(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_ClearCache(void * jarg1) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + (arg1)->ClearCache(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_DeleteApplicationCache(void * jarg1, void * jarg2) { + Dali::WebEngineContext * arg1 = (Dali::WebEngineContext *)jarg1; + Dali::WebEngineSecurityOrigin * origin = (Dali::WebEngineSecurityOrigin *)jarg2; + bool result = false; + { + try { + result = (arg1)->DeleteApplicationCache(*origin); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_GetFormPasswordList(void *jarg1, void *jarg2) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; + void (*handler)(std::vector>*) = (void (*)(std::vector>*))jarg2; + { + try { + (arg1)->GetFormPasswordList( + [handler](std::vector>& passwordList) { + std::vector>* contextPasswordList = new std::vector>(); + contextPasswordList->swap(passwordList); + handler(contextPasswordList); + }); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_RegisterDownloadStartedCallback(void * jarg1, void * jarg2) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; + void (*handler)(char *) = (void (*)(char *))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterDownloadStartedCallback( + [handler](const std::string& url) { + handler(SWIG_csharp_string_callback(url.c_str())); + }); + } + else + { + (arg1)->RegisterDownloadStartedCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_RegisterMimeOverriddenCallback(void *jarg1, void *jarg2) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; + bool (*handler)(char *, char *, char *) = (bool (*)(char *, char *, char *))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterMimeOverriddenCallback( + [handler](const std::string& url, const std::string& mime, std::string& newMime) -> bool { + return handler(SWIG_csharp_string_callback(url.c_str()), + SWIG_csharp_string_callback(mime.c_str()), + SWIG_csharp_string_callback(newMime.c_str())); + }); + } + else + { + (arg1)->RegisterMimeOverriddenCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_RegisterRequestInterceptedCallback(void * jarg1, void * jarg2) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; + void (*handler)(Dali::WebEngineRequestInterceptorPtr*) = (void (*)(Dali::WebEngineRequestInterceptorPtr*))jarg2; + { + try { + if (handler) + { + (arg1)->RegisterRequestInterceptedCallback([handler](Dali::WebEngineRequestInterceptorPtr interceptor) { + Dali::WebEngineRequestInterceptorPtr* interceptorPtr = new Dali::WebEngineRequestInterceptorPtr((const Dali::WebEngineRequestInterceptorPtr&)interceptor); + handler(interceptorPtr); + }); + } + else + { + (arg1)->RegisterRequestInterceptedCallback(nullptr); + } + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_EnableCache(void * jarg1, bool jarg2) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + (arg1)->EnableCache(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_IsCacheEnabled(void *jarg1) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + bool ret; + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + ret = (arg1)->IsCacheEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetAppId(void *jarg1, char *jarg2) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return; + } + + const std::string str(jarg2); + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + (arg1)->SetAppId(str); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_SetAppVersion(void *jarg1, char *jarg2) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return false; + } + + const std::string str(jarg2); + bool ret; + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + ret = (arg1)->SetAppVersion(str); + } CALL_CATCH_EXCEPTION(0); + } + + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetApplicationType(void *jarg1, int jarg2) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + (arg1)->SetApplicationType((Dali::WebEngineContext::ApplicationType)jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetTimeOffset(void *jarg1, float jarg2) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + (arg1)->SetTimeOffset(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetTimeZoneOffset(void *jarg1, float jarg2, float jarg3) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + (arg1)->SetTimeZoneOffset(jarg2, jarg3); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_RegisterUrlSchemesAsCorsEnabled(void *jarg1, char **jarg2, unsigned int jarg3) { + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return; + } + + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + std::vector vecStr; + for (unsigned int i=0; iRegisterUrlSchemesAsCorsEnabled(vecStr); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_RegisterJsPluginMimeTypes(void *jarg1, char **jarg2, unsigned int jarg3) { + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return; + } + + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + std::vector vecStr; + for (unsigned int i=0; iRegisterJsPluginMimeTypes(vecStr); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetDefaultZoomFactor(void *jarg1, float jarg2) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + (arg1)->SetDefaultZoomFactor(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WebContext_GetDefaultZoomFactor(void *jarg1) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + float ret; + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + ret = (arg1)->GetDefaultZoomFactor(); + } CALL_CATCH_EXCEPTION(0); + } + + return ret; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_DeleteAllApplicationCache(void *jarg1) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + bool ret; + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + ret = (arg1)->DeleteAllApplicationCache(); + } CALL_CATCH_EXCEPTION(0); + } + + return ret; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_DeleteAllWebIndexedDatabase(void *jarg1) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + bool ret; + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + ret = (arg1)->DeleteAllWebIndexedDatabase(); + } CALL_CATCH_EXCEPTION(0); + } + + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_DeleteFormPasswordDataList(void *jarg1, char **jarg2, unsigned int jarg3) { + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return; + } + + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + std::vector vecStr; + for (unsigned int i=0; iDeleteFormPasswordDataList(vecStr); + } CALL_CATCH_EXCEPTION() + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_DeleteAllFormPasswordData(void *jarg1) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + (arg1)->DeleteAllFormPasswordData(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_DeleteAllFormCandidateData(void *jarg1) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + (arg1)->DeleteAllFormCandidateData(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_FreeUnusedMemory(void *jarg1) { + Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; + bool ret; + arg1 = (Dali::WebEngineContext *)jarg1; + { + try { + ret = (arg1)->FreeUnusedMemory(); + } CALL_CATCH_EXCEPTION(0); + } + + return ret; +} + +//----------------------------------WebContextMenu--------------------------------------------------- +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebContextMenu(void * jarg1) { + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebContextMenu is null", 0); + return; + } + + Dali::WebEngineContextMenu* arg1 = (Dali::WebEngineContextMenu*)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebContextMenu_GetItemCount(void *jarg1) { + Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1; + uint32_t ret; + { + try { + ret = (arg1)->GetItemCount(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebContextMenu_GetItemAt(void *jarg1, uint32_t jarg2) { + Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1; + Dali::WebEngineContextMenuItem *result = 0; + { + try { + std::unique_ptr item = (arg1)->GetItemAt(jarg2); + result = item.release(); + } CALL_CATCH_EXCEPTION(0); + } + return (void *)result; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebContextMenu_GetItemList(void *jarg1) { + Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1; + std::vector>* result = nullptr; + { + try { + result = new std::vector>(); + std::vector> itemList = (arg1)->GetItemList(); + result->swap(itemList); + } CALL_CATCH_EXCEPTION(0); + } + return (void *)result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContextMenu_RemoveItem(void *jarg1, void *jarg2) { + Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1; + bool result = 0; + { + try { + result = (arg1)->RemoveItem(*((Dali::WebEngineContextMenuItem*)jarg2)); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContextMenu_AppendItemAsAction(void *jarg1, int jarg2, const char *jarg3, bool jarg4) { + Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1; + bool result = 0; + { + try { + result = (arg1)->AppendItemAsAction((Dali::WebEngineContextMenuItem::ItemTag)jarg2, jarg3, jarg4); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContextMenu_AppendItem(void *jarg1, int jarg2, const char *jarg3, const char *jarg4, bool jarg5) { + Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1; + bool result = 0; + { + try { + result = (arg1)->AppendItem((Dali::WebEngineContextMenuItem::ItemTag)jarg2, jarg3, jarg4, jarg5); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContextMenu_SelectItem(void *jarg1, void *jarg2) { + Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1; + bool result = 0; + { + try { + result = (arg1)->SelectItem(*((Dali::WebEngineContextMenuItem*)jarg2)); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContextMenu_Hide(void *jarg1) { + Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1; + bool result = 0; + { + try { + result = (arg1)->Hide(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +//----------------------------------WebContextMenuItem--------------------------------------------------- +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebContextMenuItem(void * jarg1) { + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebContextMenuItem is null", 0); + return; + } + + Dali::WebEngineContextMenuItem* arg1 = (Dali::WebEngineContextMenuItem*)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebContextMenuItem_GetTag(void *jarg1) { + Dali::WebEngineContextMenuItem *arg1 = (Dali::WebEngineContextMenuItem *)jarg1; + int result = 0; + { + try { + result = (int)(arg1)->GetTag(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebContextMenuItem_GetType(void *jarg1) { + Dali::WebEngineContextMenuItem *arg1 = (Dali::WebEngineContextMenuItem *)jarg1; + int result = 0; + { + try { + result = (int)(arg1)->GetType(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContextMenuItem_IsEnabled(void *jarg1) { + Dali::WebEngineContextMenuItem *arg1 = (Dali::WebEngineContextMenuItem *)jarg1; + bool result = 0; + { + try { + result = (arg1)->IsEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebContextMenuItem_GetLinkUrl(void *jarg1) { + Dali::WebEngineContextMenuItem *arg1 = (Dali::WebEngineContextMenuItem *)jarg1; + std::string result; + { + try { + result = (arg1)->GetLinkUrl(); + } CALL_CATCH_EXCEPTION(0); + } + char *jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebContextMenuItem_GetImageUrl(void *jarg1) { + Dali::WebEngineContextMenuItem *arg1 = (Dali::WebEngineContextMenuItem *)jarg1; + std::string result; + { + try { + result = (arg1)->GetImageUrl(); + } CALL_CATCH_EXCEPTION(0); + } + char *jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebContextMenuItem_GetTitle(void *jarg1) { + Dali::WebEngineContextMenuItem *arg1 = (Dali::WebEngineContextMenuItem *)jarg1; + std::string result; + { + try { + result = (arg1)->GetTitle(); + } CALL_CATCH_EXCEPTION(0); + } + char *jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebContextMenuItem_GetParentMenu(void *jarg1) { + Dali::WebEngineContextMenuItem* arg1 = (Dali::WebEngineContextMenuItem*)jarg1; + Dali::WebEngineContextMenu* result = 0; + { + try { + std::unique_ptr item = (arg1)->GetParentMenu(); + result = item.release(); + } CALL_CATCH_EXCEPTION(0); + } + return (void *)result; +} + +//----------------------------------WebContextMenuItemList--------------------------------------------------- +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebContextMenu_ItemList(void * jarg1) { + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebContextMenu ItemList is null", 0); + return; + } + + std::vector>* arg1 = (std::vector>*)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebContextMenu_ItemList_GetItemCount(void* jarg1) { + std::vector>* arg1 = (std::vector>*)jarg1; + uint32_t result = 0; + { + try { + result = (arg1)->size(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebContextMenu_ItemList_ValueOfIndex(void* jarg1, unsigned int jarg2) { + std::vector>* arg1 = (std::vector>*)jarg1; + Dali::WebEngineContextMenuItem* result = 0; + { + try { + result = ((arg1)->operator[](jarg2)).get(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +//----------------------------------WebCookieManager--------------------------------------------------- +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebCookieManager_GetCookieAcceptPolicy(void * jarg1) { + Dali::WebEngineCookieManager* arg1 = (Dali::WebEngineCookieManager*)0; + int ret; + + arg1 = (Dali::WebEngineCookieManager*)jarg1; + { + try { + ret = (int)(arg1)->GetCookieAcceptPolicy(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebCookieManager_SetCookieAcceptPolicy(void * jarg1, int jarg2) { + Dali::WebEngineCookieManager* arg1 = (Dali::WebEngineCookieManager*)0; + arg1 = (Dali::WebEngineCookieManager*)jarg1; + { + try { + (arg1)->SetCookieAcceptPolicy( + (Dali::WebEngineCookieManager::CookieAcceptPolicy)jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebCookieManager_SetPersistentStorage(void * jarg1, const char * jarg2, int jarg3) { + Dali::WebEngineCookieManager* arg1 = (Dali::WebEngineCookieManager*)0; + + arg1 = (Dali::WebEngineCookieManager*)jarg1; + std::string arg2_str(jarg2); + Dali::WebEngineCookieManager::CookiePersistentStorage arg3_enum = (Dali::WebEngineCookieManager::CookiePersistentStorage)jarg3; + { + try { + (arg1)->SetPersistentStorage(arg2_str, arg3_enum); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebCookieManager_ClearCookies(void * jarg1) { + Dali::WebEngineCookieManager* arg1 = (Dali::WebEngineCookieManager*)0; + + arg1 = (Dali::WebEngineCookieManager*)jarg1; + { + try { + (arg1)->ClearCookies(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebCookieManager_ChangesWatch(void *jarg1, void *jarg2) { + Dali::WebEngineCookieManager *arg1 = (Dali::WebEngineCookieManager *)jarg1; + void (*callback)() = (void (*)())jarg2; + { + try { + (arg1)->ChangesWatch(callback); + } CALL_CATCH_EXCEPTION(); + } +} + +//----------------------------------WebFormRepostDecision--------------------------------------------------- +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebFormRepostDecision(void * jarg1) { + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebFormRepostDecision is null", 0); + return; + } + + Dali::WebEngineFormRepostDecision* arg1 = (Dali::WebEngineFormRepostDecision*)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebFormRepostDecision_Reply(void *jarg1, bool jarg2) { + Dali::WebEngineFormRepostDecision* arg1 = (Dali::WebEngineFormRepostDecision*)jarg1; + { + try { + arg1->Reply(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +//----------------------------------WebFrame--------------------------------------------------- +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebFrame_IsMainFrame(void* jarg1) { + Dali::WebEngineFrame* arg1 = (Dali::WebEngineFrame*)jarg1; + bool result = false; + { + try { + result = (arg1)->IsMainFrame(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +//----------------------------------WebPolicyDecision----------------------------------------------------- +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebPolicyDecision(void * jarg1) { + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebPolicyDecision is null", 0); + return; + } + + Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetUrl(void* jarg1) { + Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; + std::string result; + { + try { + result = arg1->GetUrl(); + } CALL_CATCH_EXCEPTION(0); + } + char* jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetCookie(void* jarg1) { + Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; + std::string result; + { + try { + result = arg1->GetCookie(); + } CALL_CATCH_EXCEPTION(0); + } + char* jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetDecisionType(void* jarg1) { + Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; + int result; + { + try { + result = (int)arg1->GetDecisionType(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetResponseMime(void* jarg1) { + Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; + std::string result; + { + try { + result = arg1->GetResponseMime(); + } CALL_CATCH_EXCEPTION(0); + } + char* jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetResponseStatusCode(void* jarg1) { + Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; + int result; + { + try { + result = arg1->GetResponseStatusCode(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetNavigationType(void* jarg1) { + Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; + int result; + { + try { + result = (int)arg1->GetNavigationType(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetFrame(void* jarg1) { + Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; + Dali::WebEngineFrame* result = 0; + { + try { + result = &((arg1)->GetFrame()); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetScheme(void* jarg1) { + Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; + std::string result; + { + try { + result = arg1->GetScheme(); + } CALL_CATCH_EXCEPTION(0); + } + char* jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebPolicyDecision_Use(void* jarg1) { + Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; + bool result; + { + try { + result = arg1->Use(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebPolicyDecision_Ignore(void* jarg1) { + Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; + bool result; + { + try { + result = arg1->Ignore(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebPolicyDecision_Suspend(void* jarg1) { + Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; + bool result; + { + try { + result = arg1->Suspend(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +//----------------------------------WebRequestInterceptorPtr--------------------------------------------------- +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebRequestInterceptorPtr(void * jarg1) { + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebRequestInterceptorPtr is null", 0); + return; + } + + Dali::WebEngineRequestInterceptorPtr* arg1 = (Dali::WebEngineRequestInterceptorPtr*)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebRequestInterceptorPtr_Get(void * jarg1) { + Dali::WebEngineRequestInterceptorPtr* arg1 = (Dali::WebEngineRequestInterceptorPtr*)jarg1; + Dali::WebEngineRequestInterceptor* result = 0; + { + try { + result = arg1->Get(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +//----------------------------------WebRequestInterceptor--------------------------------------------------- +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_GetWebView(void * jarg1) { + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebRequestInterceptor is null", 0); + return 0; + } + + Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; + Dali::Toolkit::WebView result; + + Dali::WebEnginePlugin* plugin = nullptr; + { + try { + plugin = (arg1)->GetWebEngine(); + } CALL_CATCH_EXCEPTION(0); + } + + if (!plugin) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebEnginePlugin is null", 0); + return 0; + } + + { + try { + result = Dali::Toolkit::WebView::FindWebView(plugin); + } CALL_CATCH_EXCEPTION(0); + } + void* jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView&)result); + return jresult; +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_GetUrl(void * jarg1) { + Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; + std::string result; + { + try { + result = (arg1)->GetUrl(); + } CALL_CATCH_EXCEPTION(0); + } + char* jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_GetMethod(void * jarg1) { + Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; + std::string result; + { + try { + result = (arg1)->GetMethod(); + } CALL_CATCH_EXCEPTION(0); + } + char* jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_GetHeaders(void * jarg1) { + Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; + Dali::Property::Map * result = 0; + { + try { + Dali::Property::Map headers = (arg1)->GetHeaders(); + result = new Dali::Property::Map(headers); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_Ignore(void * jarg1) { + Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; + bool ret = false; + { + try { + ret = (arg1)->Ignore(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_SetResponseStatus(void * jarg1, int jarg2, const char *jarg3) { + Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; + bool ret = false; + std::string arg3_str(jarg3); + { + try { + ret = (arg1)->SetResponseStatus(jarg2, arg3_str); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_AddResponseHeader(void * jarg1, const char * jarg2, const char * jarg3) { + Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; + bool ret = false; + std::string arg2_str(jarg2); + std::string arg3_str(jarg3); + { + try { + ret = (arg1)->AddResponseHeader(arg2_str, arg3_str); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_AddResponseHeaders(void * jarg1, void * jarg2) { + Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; + Dali::Property::Map* arg2 = (Dali::Property::Map*)jarg2; + bool ret = false; + { + try { + ret = (arg1)->AddResponseHeaders(*arg2); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_AddResponseBody(void * jarg1, const int8_t * jarg2, uint32_t jarg3) { + Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; + bool ret = false; + { + try { + ret = (arg1)->AddResponseBody(jarg2, jarg3); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_AddResponse(void * jarg1, const char * jarg2, const int8_t * jarg3, uint32_t jarg4) { + Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; + bool ret = false; + std::string arg2_str(jarg2); + { + try { + ret = (arg1)->AddResponse(arg2_str, jarg3, jarg4); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_WriteResponseChunk(void * jarg1, const int8_t * jarg2, uint32_t jarg3) { + Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; + bool ret = false; + { + try { + ret = (arg1)->WriteResponseChunk(jarg2, jarg3); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +//----------------------------------WebHttpAuthHandler--------------------------------------------------- +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebHttpAuthHandler(void * jarg1) { + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebHttpAuthHandler is null", 0); + return; + } + + Dali::WebEngineHttpAuthHandler* arg1 = (Dali::WebEngineHttpAuthHandler*)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT const char *SWIGSTDCALL CSharp_Dali_WebHttpAuthHandler_GetRealm(void * jarg1) { + Dali::WebEngineHttpAuthHandler* arg1 = (Dali::WebEngineHttpAuthHandler*)jarg1; + std::string result; + { + try { + result = (arg1)->GetRealm(); + } CALL_CATCH_EXCEPTION(0); + } + char *jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebHttpAuthHandler_Suspend(void * jarg1) { + Dali::WebEngineHttpAuthHandler* arg1 = (Dali::WebEngineHttpAuthHandler*)jarg1; + { + try { + (arg1)->Suspend(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebHttpAuthHandler_UseCredential( + void * jarg1, const char *jarg2, const char *jarg3) { + Dali::WebEngineHttpAuthHandler* arg1 = (Dali::WebEngineHttpAuthHandler*)jarg1; + std::string arg2_str(jarg2); + std::string arg3_str(jarg3); + { + try { + (arg1)->UseCredential(arg2_str, arg3_str); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebHttpAuthHandler_CancelCredential(void * jarg1) { + Dali::WebEngineHttpAuthHandler* arg1 = (Dali::WebEngineHttpAuthHandler*)jarg1; + { + try { + (arg1)->CancelCredential(); + } CALL_CATCH_EXCEPTION(); + } +} + +//----------------------------------WebPasswordData--------------------------------------------------- +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebPasswordData_GetUrl(void * jarg1) { + Dali::WebEngineContext::PasswordData *arg1 = (Dali::WebEngineContext::PasswordData *)jarg1; + std::string result; + { + try { + result = (arg1)->url; + } CALL_CATCH_EXCEPTION(0); + } + char * jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebPasswordData_GetUseFingerprint(void * jarg1) { + Dali::WebEngineContext::PasswordData * arg1 = (Dali::WebEngineContext::PasswordData *)jarg1; + bool result = false; + { + try { + result = (arg1)->useFingerprint; + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +//----------------------------------WebLoadError----------------------------------------------------- +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebLoadError(void * jarg1) { + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebLoadError is null", 0); + return; + } + + Dali::WebEngineLoadError* arg1 = (Dali::WebEngineLoadError*)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebLoadError_GetUrl(void* jarg1) { + Dali::WebEngineLoadError* arg1 = (Dali::WebEngineLoadError*)jarg1; + std::string result; + { + try { + result = arg1->GetUrl(); + } CALL_CATCH_EXCEPTION(0); + } + char* jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebLoadError_GetCode(void* jarg1) { + Dali::WebEngineLoadError* arg1 = (Dali::WebEngineLoadError*)jarg1; + int result; + { + try { + result = (int)arg1->GetCode(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebLoadError_GetDescription(void* jarg1) { + Dali::WebEngineLoadError* arg1 = (Dali::WebEngineLoadError*)jarg1; + std::string result; + { + try { + result = arg1->GetDescription(); + } CALL_CATCH_EXCEPTION(0); + } + char* jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebLoadError_GetType(void* jarg1) { + Dali::WebEngineLoadError* arg1 = (Dali::WebEngineLoadError*)jarg1; + int result; + { + try { + result = (int)arg1->GetType(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +//----------------------------------WebPasswordDataList--------------------------------------------------- +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebPasswordDataList(void * jarg1) { + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebEngineContext::PasswordData List is null", 0); + return; + } + + std::vector>* arg1 = (std::vector>*)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebPasswordDataList_GetItemCount(void* jarg1) { + std::vector>* arg1 = (std::vector>*)jarg1; + uint32_t result = 0; + { + try { + result = (arg1)->size(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebPasswordDataList_ValueOfIndex(void * jarg1, unsigned int jarg2) { + std::vector>* arg1 = (std::vector>*)jarg1; + Dali::WebEngineContext::PasswordData* result = 0; + { + try { + result = ((arg1)->operator[](jarg2)).get(); + } CALL_CATCH_EXCEPTION(0); + } + + return result; +} + +//----------------------------------WebSecurityOrigin--------------------------------------------------- +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebSecurityOrigin_GetHost(void * jarg1) { + Dali::WebEngineSecurityOrigin *arg1 = (Dali::WebEngineSecurityOrigin *)jarg1; + std::string result; + { + try { + result = (arg1)->GetHost(); + } CALL_CATCH_EXCEPTION(0); + } + char * jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebSecurityOrigin_GetProtocol(void * jarg1) { + Dali::WebEngineSecurityOrigin *arg1 = (Dali::WebEngineSecurityOrigin *)jarg1; + std::string result; + { + try { + result = (arg1)->GetProtocol(); + } CALL_CATCH_EXCEPTION(0); + } + char * jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +//----------------------------------WebSecurityOriginList--------------------------------------------------- +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebSecurityOriginList(void *jarg1) { + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebEngineSecurityOrigin List is null", 0); + return; + } + + std::vector>* arg1 = (std::vector>*)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebSecurityOriginList_GetItemCount(void* jarg1) { + std::vector>* arg1 = (std::vector>*)jarg1; + uint32_t result = 0; + { + try { + result = (arg1)->size(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebSecurityOriginList_ValueOfIndex(void *jarg1, unsigned int jarg2) { + std::vector>* arg1 = (std::vector>*)jarg1; + Dali::WebEngineSecurityOrigin * result = 0; + { + try { + result = ((arg1)->operator[](jarg2)).get(); + } CALL_CATCH_EXCEPTION(0); + } + return result; +} + +//----------------------------------WebHitTest--------------------------------------------------- +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebHitTest(void * jarg1) { + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebEngineHitTest is null", 0); + return; + } + + Dali::WebEngineHitTest* arg1 = (Dali::WebEngineHitTest*)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebHitTest_GetResultContext(void * jarg1) { + Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1; + int ret; + { + try { + ret = (int)(arg1)->GetResultContext(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetLinkUri(void * jarg1) { + Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1; + std::string result; + { + try { + result = (arg1)->GetLinkUri(); + } CALL_CATCH_EXCEPTION(0); + } + char *jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetLinkTitle(void * jarg1) { + Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1; + std::string result; + { + try { + result = (arg1)->GetLinkTitle(); + } CALL_CATCH_EXCEPTION(0); + } + char *jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetLinkLabel(void * jarg1) { + Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1; + std::string result; + { + try { + result = (arg1)->GetLinkLabel(); + } CALL_CATCH_EXCEPTION(0); + } + char *jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetImageUri(void * jarg1) { + Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1; + std::string result; + { + try { + result = (arg1)->GetImageUri(); + } CALL_CATCH_EXCEPTION(0); + } + char * jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetMediaUri(void * jarg1) { + Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1; + std::string result; + { + try { + result = (arg1)->GetMediaUri(); + } CALL_CATCH_EXCEPTION(0); + } + char * jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetTagName(void * jarg1) { + Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1; + std::string result; + { + try { + result = (arg1)->GetTagName(); + } CALL_CATCH_EXCEPTION(0); + } + char *jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetNodeValue(void * jarg1) { + Dali::WebEngineHitTest * arg1 = (Dali::WebEngineHitTest *)jarg1; + std::string result; + { + try { + result = (arg1)->GetNodeValue(); + } CALL_CATCH_EXCEPTION(0); + } + char * jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebHitTest_GetAttributes(void * jarg1) { + Dali::WebEngineHitTest * arg1 = (Dali::WebEngineHitTest *)jarg1; + Dali::Property::Map * result = 0; + { + try { + Dali::Property::Map attributes = (arg1)->GetAttributes(); + result = new Dali::Property::Map(attributes); + } CALL_CATCH_EXCEPTION(0); + } + return (void *)result; +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetImageFileNameExtension(void * jarg1) { + Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1; + std::string result; + { + try { + result = (arg1)->GetImageFileNameExtension(); + } CALL_CATCH_EXCEPTION(0); + } + char *jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebHitTest_GetImageBuffer(void * jarg1) { + Dali::WebEngineHitTest* arg1 = (Dali::WebEngineHitTest *)jarg1; + Dali::PixelData result; + { + try { + result = (arg1)->GetImageBuffer(); + } CALL_CATCH_EXCEPTION(0); + } + + Dali::PixelData* jresult = new Dali::PixelData((const Dali::PixelData &)result); + return (void *)jresult; +} + +//----------------------------------WebSettings--------------------------------------------------- +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_AllowMixedContents(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + (arg1)->AllowMixedContents(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableSpatialNavigation(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + (arg1)->EnableSpatialNavigation(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebSettings_GetDefaultFontSize(void * jarg1) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + int ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->GetDefaultFontSize(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_SetDefaultFontSize(void * jarg1, int jarg2) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + (arg1)->SetDefaultFontSize(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableWebSecurity(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + (arg1)->EnableWebSecurity(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableCacheBuilder(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; + + arg1 = (Dali::Toolkit::WebSettings*)jarg1; + { + try { + (arg1)->EnableCacheBuilder(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_UseScrollbarThumbFocusNotifications(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; + + arg1 = (Dali::Toolkit::WebSettings*)jarg1; + { + try { + (arg1)->UseScrollbarThumbFocusNotifications(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableDoNotTrack(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; + + arg1 = (Dali::Toolkit::WebSettings*)jarg1; + { + try { + (arg1)->EnableDoNotTrack(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_AllowFileAccessFromExternalUrl(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + (arg1)->AllowFileAccessFromExternalUrl(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsJavaScriptEnabled(void * jarg1) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->IsJavaScriptEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableJavaScript(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + (arg1)->EnableJavaScript(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsAutoFittingEnabled(void * jarg1) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->IsAutoFittingEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableAutoFitting(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; + + arg1 = (Dali::Toolkit::WebSettings*)jarg1; + { + try { + (arg1)->EnableAutoFitting(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_ArePluginsEnabled(void * jarg1) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->ArePluginsEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnablePlugins(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; + + arg1 = (Dali::Toolkit::WebSettings*)jarg1; + { + try { + (arg1)->EnablePlugins(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsPrivateBrowsingEnabled(void * jarg1) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->IsPrivateBrowsingEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnablePrivateBrowsing(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; + + arg1 = (Dali::Toolkit::WebSettings*)jarg1; + { + try { + (arg1)->EnablePrivateBrowsing(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsLinkMagnifierEnabled(void * jarg1) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->IsLinkMagnifierEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableLinkMagnifier(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; + + arg1 = (Dali::Toolkit::WebSettings*)jarg1; + { + try { + (arg1)->EnableLinkMagnifier(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsKeypadWithoutUserActionUsed(void * jarg1) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->IsKeypadWithoutUserActionUsed(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_UseKeypadWithoutUserAction(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; + + arg1 = (Dali::Toolkit::WebSettings*)jarg1; + { + try { + (arg1)->UseKeypadWithoutUserAction(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsAutofillPasswordFormEnabled(void * jarg1) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->IsAutofillPasswordFormEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableAutofillPasswordForm(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; + + arg1 = (Dali::Toolkit::WebSettings*)jarg1; + { + try { + (arg1)->EnableAutofillPasswordForm(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsFormCandidateDataEnabled(void * jarg1) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->IsFormCandidateDataEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableFormCandidateData(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; + + arg1 = (Dali::Toolkit::WebSettings*)jarg1; + { + try { + (arg1)->EnableFormCandidateData(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsTextSelectionEnabled(void * jarg1) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->IsTextSelectionEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableTextSelection(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; + + arg1 = (Dali::Toolkit::WebSettings*)jarg1; + { + try { + (arg1)->EnableTextSelection(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsTextAutosizingEnabled(void * jarg1) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->IsTextAutosizingEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableTextAutosizing(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; + + arg1 = (Dali::Toolkit::WebSettings*)jarg1; + { + try { + (arg1)->EnableTextAutosizing(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsArrowScrollEnabled(void * jarg1) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->IsArrowScrollEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableArrowScroll(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; + + arg1 = (Dali::Toolkit::WebSettings*)jarg1; + { + try { + (arg1)->EnableArrowScroll(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsClipboardEnabled(void * jarg1) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->IsClipboardEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableClipboard(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; + + arg1 = (Dali::Toolkit::WebSettings*)jarg1; + { + try { + (arg1)->EnableClipboard(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsImePanelEnabled(void * jarg1) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->IsImePanelEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableImePanel(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; + + arg1 = (Dali::Toolkit::WebSettings*)jarg1; + { + try { + (arg1)->EnableImePanel(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_AllowScriptsOpenWindows(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + (arg1)->AllowScriptsOpenWindows(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_AreImagesLoadedAutomatically(void * jarg1) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->AreImagesLoadedAutomatically(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_AllowImagesLoadAutomatically(void * jarg1, bool jarg2) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + (arg1)->AllowImagesLoadAutomatically(jarg2); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebSettings_GetDefaultTextEncodingName(void * jarg1) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + std::string result; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + result = (arg1)->GetDefaultTextEncodingName(); + } CALL_CATCH_EXCEPTION(0); + } + char * jresult = SWIG_csharp_string_callback(result.c_str()); + return jresult; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_SetDefaultTextEncodingName(void * jarg1, const char * jarg2) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + std::string arg2_str(jarg2); + { + try { + (arg1)->SetDefaultTextEncodingName(arg2_str); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_SetViewportMetaTag(void *jarg1, bool jarg2) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->SetViewportMetaTag(jarg2); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_SetForceZoom(void *jarg1, bool jarg2) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->SetForceZoom(jarg2); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsZoomForced(void *jarg1) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->IsZoomForced(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_SetTextZoomEnabled(void *jarg1, bool jarg2) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->SetTextZoomEnabled(jarg2); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsTextZoomEnabled(void *jarg1) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->IsTextZoomEnabled(); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_SetExtraFeature(void *jarg1, const char *jarg2, bool jarg3) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + std::string arg2(jarg2); + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + (arg1)->SetExtraFeature(arg2, jarg3); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsExtraFeatureEnabled(void *jarg1, const char *jarg2) { + Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; + std::string arg2(jarg2); + bool ret; + + arg1 = (Dali::Toolkit::WebSettings *)jarg1; + { + try { + ret = (arg1)->IsExtraFeatureEnabled(arg2); + } CALL_CATCH_EXCEPTION(0); + } + return ret; +} + +#ifdef __cplusplus +} // end extern "C" +#endif diff --git a/dali-csharp-binder/file.list b/dali-csharp-binder/file.list index 019d7fc6..5781325b 100755 --- a/dali-csharp-binder/file.list +++ b/dali-csharp-binder/file.list @@ -7,107 +7,115 @@ SET( dali_csharp_binder_dir ${CMAKE_CURRENT_SOURCE_DIR}/../../dali-csharp-binder # module: csharp-binder, backend: common - ubuntu,mobile,tv,ivi,tizen-wearable,common SET( dali_csharp_binder_common_src_files - ${dali_csharp_binder_dir}/src/common.cpp - ${dali_csharp_binder_dir}/src/dali-wrap.cpp - ${dali_csharp_binder_dir}/src/actor-wrap.cpp - ${dali_csharp_binder_dir}/src/layer-wrap.cpp - ${dali_csharp_binder_dir}/src/callbackbase-wrap.cpp - ${dali_csharp_binder_dir}/src/canvas-view-wrap.cpp - ${dali_csharp_binder_dir}/src/constraint-wrap.cpp - ${dali_csharp_binder_dir}/src/keyboard-focus-manager-wrap.cpp - ${dali_csharp_binder_dir}/src/devel-property-wrap.cpp - ${dali_csharp_binder_dir}/src/encoded-image-buffer-wrap.cpp - ${dali_csharp_binder_dir}/src/version-check.cpp - ${dali_csharp_binder_dir}/src/processor-controller.cpp - ${dali_csharp_binder_dir}/src/flex-layout-wrap.cpp - ${dali_csharp_binder_dir}/src/gestures-wrap.cpp - ${dali_csharp_binder_dir}/src/view-wrapper-impl-wrap.cpp - ${dali_csharp_binder_dir}/src/visual-actions-wrap.cpp - ${dali_csharp_binder_dir}/src/event-thread-callback-wrap.cpp - ${dali_csharp_binder_dir}/src/application-wrap.cpp - ${dali_csharp_binder_dir}/src/text-editor-wrap.cpp - ${dali_csharp_binder_dir}/src/text-field-wrap.cpp - ${dali_csharp_binder_dir}/src/fade-transition-wrap.cpp - ${dali_csharp_binder_dir}/src/slide-transition-wrap.cpp - ${dali_csharp_binder_dir}/src/scale-transition-wrap.cpp - ${dali_csharp_binder_dir}/src/transition-base-wrap.cpp - ${dali_csharp_binder_dir}/src/transition-wrap.cpp - ${dali_csharp_binder_dir}/src/transition-set-wrap.cpp - ${dali_csharp_binder_dir}/src/window-wrap.cpp - ${dali_csharp_binder_dir}/src/tts-player-wrap.cpp - ${dali_csharp_binder_dir}/src/input-method-context-wrap.cpp - ${dali_csharp_binder_dir}/src/input-method-options-wrap.cpp - ${dali_csharp_binder_dir}/src/internal-property-get-set-wrap.cpp - ${dali_csharp_binder_dir}/src/internal-visual-property-get-set-wrap.cpp - ${dali_csharp_binder_dir}/src/animation-wrap.cpp - ${dali_csharp_binder_dir}/src/adaptor-wrap.cpp - ${dali_csharp_binder_dir}/src/extents-wrap.cpp - ${dali_csharp_binder_dir}/src/text-geometry-wrap.cpp - ${dali_csharp_binder_dir}/src/text-label-wrap.cpp - ${dali_csharp_binder_dir}/src/text-range-wrap.cpp - ${dali_csharp_binder_dir}/src/text-spans-wrap.cpp - ${dali_csharp_binder_dir}/src/text-character-sequence-wrap.cpp - ${dali_csharp_binder_dir}/src/text-spanned-wrap.cpp - ${dali_csharp_binder_dir}/src/text-spannable-wrap.cpp - ${dali_csharp_binder_dir}/src/text-spannable-string-wrap.cpp - ${dali_csharp_binder_dir}/src/text-spannable-api-wrap.cpp - ${dali_csharp_binder_dir}/src/text-utils-wrap.cpp - ${dali_csharp_binder_dir}/src/capabilities-wrap.cpp - ${dali_csharp_binder_dir}/src/capture-wrap.cpp - ${dali_csharp_binder_dir}/src/gl-window-wrap.cpp - ${dali_csharp_binder_dir}/src/gl-view-wrap.cpp - ${dali_csharp_binder_dir}/src/web-view-wrap.cpp - ${dali_csharp_binder_dir}/src/control-devel-wrap.cpp - ${dali_csharp_binder_dir}/src/signal-wrap.cpp - ${dali_csharp_binder_dir}/src/nui-view-accessible.cpp - ${dali_csharp_binder_dir}/src/atspi-wrap.cpp - ${dali_csharp_binder_dir}/src/rotation-wrap.cpp - ${dali_csharp_binder_dir}/src/input-options-wrap.cpp - ${dali_csharp_binder_dir}/src/native-image-queue-wrap.cpp - ${dali_csharp_binder_dir}/src/style-manager-wrap.cpp - ${dali_csharp_binder_dir}/src/drag-and-drop-wrap.cpp - ${dali_csharp_binder_dir}/src/font-client-wrap.cpp - ${dali_csharp_binder_dir}/src/slim-custom-view-impl.cpp - ${dali_csharp_binder_dir}/src/window-data-wrap.cpp + ${dali_csharp_binder_dir}/common/common.cpp + ${dali_csharp_binder_dir}/common/dali-wrap.cpp + ${dali_csharp_binder_dir}/common/callbackbase-wrap.cpp + ${dali_csharp_binder_dir}/common/nui-view-accessible.cpp + ${dali_csharp_binder_dir}/common/processor-controller.cpp + ${dali_csharp_binder_dir}/common/signal-wrap.cpp + ${dali_csharp_binder_dir}/common/slim-custom-view-impl.cpp + ${dali_csharp_binder_dir}/common/version-check.cpp + ${dali_csharp_binder_dir}/common/view-wrapper-impl-wrap.cpp + + ${dali_csharp_binder_dir}/dali-core/dali-core-wrap.cpp + ${dali_csharp_binder_dir}/dali-core/actor-wrap.cpp + ${dali_csharp_binder_dir}/dali-core/animation-wrap.cpp + ${dali_csharp_binder_dir}/dali-core/capabilities-wrap.cpp + ${dali_csharp_binder_dir}/dali-core/constraint-wrap.cpp + ${dali_csharp_binder_dir}/dali-core/extents-wrap.cpp + ${dali_csharp_binder_dir}/dali-core/gestures-wrap.cpp + ${dali_csharp_binder_dir}/dali-core/input-options-wrap.cpp + ${dali_csharp_binder_dir}/dali-core/internal-property-get-set-wrap.cpp + ${dali_csharp_binder_dir}/dali-core/layer-wrap.cpp + ${dali_csharp_binder_dir}/dali-core/ref-object-wrap.cpp + ${dali_csharp_binder_dir}/dali-core/rotation-wrap.cpp + ${dali_csharp_binder_dir}/dali-core/vector-wrap.cpp + + ${dali_csharp_binder_dir}/dali-adaptor/dali-adaptor-wrap.cpp + ${dali_csharp_binder_dir}/dali-adaptor/adaptor-wrap.cpp + ${dali_csharp_binder_dir}/dali-adaptor/application-wrap.cpp + ${dali_csharp_binder_dir}/dali-adaptor/atspi-wrap.cpp + ${dali_csharp_binder_dir}/dali-adaptor/capture-wrap.cpp + ${dali_csharp_binder_dir}/dali-adaptor/drag-and-drop-wrap.cpp + ${dali_csharp_binder_dir}/dali-adaptor/encoded-image-buffer-wrap.cpp + ${dali_csharp_binder_dir}/dali-adaptor/event-thread-callback-wrap.cpp + ${dali_csharp_binder_dir}/dali-adaptor/font-client-wrap.cpp + ${dali_csharp_binder_dir}/dali-adaptor/gl-window-wrap.cpp + ${dali_csharp_binder_dir}/dali-adaptor/input-method-context-wrap.cpp + ${dali_csharp_binder_dir}/dali-adaptor/input-method-options-wrap.cpp + ${dali_csharp_binder_dir}/dali-adaptor/native-image-queue-wrap.cpp + ${dali_csharp_binder_dir}/dali-adaptor/tts-player-wrap.cpp + ${dali_csharp_binder_dir}/dali-adaptor/window-data-wrap.cpp + ${dali_csharp_binder_dir}/dali-adaptor/window-wrap.cpp + + ${dali_csharp_binder_dir}/dali-toolkit/dali-toolkit-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/canvas-view-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/control-devel-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/devel-property-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/fade-transition-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/flex-layout-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/gl-view-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/internal-visual-property-get-set-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/keyboard-focus-manager-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/scale-transition-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/slide-transition-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/style-manager-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/text-character-sequence-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/text-editor-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/text-field-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/text-geometry-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/text-label-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/text-range-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/text-spans-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/text-spanned-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/text-spannable-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/text-spannable-string-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/text-spannable-api-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/text-utils-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/transition-base-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/transition-set-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/transition-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/visual-actions-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/web-view-wrap.cpp ) # added for key grab binding only for tizen # module: csharp-binder, backend: mobile,tv,ivi,watch,common SET( dali_csharp_binder_tizen_src_files - ${dali_csharp_binder_dir}/src/key-grab-wrap.cpp - ${dali_csharp_binder_dir}/src/keyboard-wrap.cpp - ${dali_csharp_binder_dir}/src/widget-view-wrap.cpp - ${dali_csharp_binder_dir}/src/widget-view-manager-wrap.cpp - ${dali_csharp_binder_dir}/src/transition-effects-wrap.cpp - ${dali_csharp_binder_dir}/src/component-application-wrap.cpp - ${dali_csharp_binder_dir}/src/tizen-dependency-wrap.cpp + ${dali_csharp_binder_dir}/dali-adaptor/component-application-wrap.cpp + ${dali_csharp_binder_dir}/dali-adaptor/keyboard-wrap.cpp + ${dali_csharp_binder_dir}/dali-adaptor/key-grab-wrap.cpp + ${dali_csharp_binder_dir}/dali-toolkit/transition-effects-wrap.cpp + ${dali_csharp_binder_dir}/widget-viewer-dali/widget-view-wrap.cpp + ${dali_csharp_binder_dir}/widget-viewer-dali/widget-view-manager-wrap.cpp + ${dali_csharp_binder_dir}/common/tizen-dependency-wrap.cpp ) # added for rive animation view for tizen # module: csharp-binder, backend: mobile,tv,ivi,watch SET( dali_csharp_binder_tizen_rive_src_files - ${dali_csharp_binder_dir}/src/rive-animation-view-wrap.cpp + ${dali_csharp_binder_dir}/dali-extension/rive-animation-view-wrap.cpp ) # module: csharp-binder, backend: tizen-wearable SET( dali_csharp_binder_tizen_wearable_src_files - ${dali_csharp_binder_dir}/src/watch-wrap.cpp - ${dali_csharp_binder_dir}/src/watch-view-wrap.cpp + ${dali_csharp_binder_dir}/dali-adaptor/watch-wrap.cpp + ${dali_csharp_binder_dir}/widget-viewer-dali/watch-view-wrap.cpp ) # module: scene3d SET( dali_csharp_binder_scene3d_src_files - ${dali_csharp_binder_dir}/src/light-wrap.cpp - ${dali_csharp_binder_dir}/src/material-wrap.cpp - ${dali_csharp_binder_dir}/src/model-node-wrap.cpp - ${dali_csharp_binder_dir}/src/model-primitive-wrap.cpp - ${dali_csharp_binder_dir}/src/model-wrap.cpp - ${dali_csharp_binder_dir}/src/motion-data-wrap.cpp - ${dali_csharp_binder_dir}/src/motion-index-wrap.cpp - ${dali_csharp_binder_dir}/src/motion-value-wrap.cpp - ${dali_csharp_binder_dir}/src/scene-view-wrap.cpp + ${dali_csharp_binder_dir}/dali-scene3d/light-wrap.cpp + ${dali_csharp_binder_dir}/dali-scene3d/material-wrap.cpp + ${dali_csharp_binder_dir}/dali-scene3d/model-node-wrap.cpp + ${dali_csharp_binder_dir}/dali-scene3d/model-primitive-wrap.cpp + ${dali_csharp_binder_dir}/dali-scene3d/model-wrap.cpp + ${dali_csharp_binder_dir}/dali-scene3d/motion-data-wrap.cpp + ${dali_csharp_binder_dir}/dali-scene3d/motion-index-wrap.cpp + ${dali_csharp_binder_dir}/dali-scene3d/motion-value-wrap.cpp + ${dali_csharp_binder_dir}/dali-scene3d/scene-view-wrap.cpp ) SET( dali_csharp_binder_header_files - ${dali_csharp_binder_dir}/src/common.h + ${dali_csharp_binder_dir}/common/common.h ) diff --git a/dali-csharp-binder/src/DaliWrapper.cpp b/dali-csharp-binder/src/DaliWrapper.cpp deleted file mode 100644 index 562ca053..00000000 --- a/dali-csharp-binder/src/DaliWrapper.cpp +++ /dev/null @@ -1,54 +0,0 @@ -/* - * 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. - * - */ - -// DaliWrapper.cpp : Defines the entry point for the DLL application. -// - -#include "stdafx.h" -#include "DaliWrapper.h" - -BOOL APIENTRY DllMain( HANDLE hModule, - DWORD ul_reason_for_call, - LPVOID lpReserved - ) -{ - switch (ul_reason_for_call) - { - case DLL_PROCESS_ATTACH: - case DLL_THREAD_ATTACH: - case DLL_THREAD_DETACH: - case DLL_PROCESS_DETACH: - break; - } - return TRUE; -} - -// This is an example of an exported variable -DALIWRAPPER_API int nDaliWrapper=0; - -// This is an example of an exported function. -DALIWRAPPER_API int fnDaliWrapper(void) -{ - return 18; -} - -// This is the constructor of a class that has been exported. -// see DaliWrapper.h for the class definition -CDaliWrapper::CDaliWrapper() -{ - return; -} diff --git a/dali-csharp-binder/src/DaliWrapper.h b/dali-csharp-binder/src/DaliWrapper.h deleted file mode 100644 index df8f4cac..00000000 --- a/dali-csharp-binder/src/DaliWrapper.h +++ /dev/null @@ -1,43 +0,0 @@ -/* - * 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. - * - */ - -// The following ifdef block is the standard way of creating macros which make exporting -// from a DLL simpler. All files within this DLL are compiled with the DALIWRAPPER_EXPORTS -// symbol defined on the command line. this symbol should not be defined on any project -// that uses this DLL. This way any other project whose source files include this file see -// DALIWRAPPER_API functions as being imported from a DLL, whereas this DLL sees symbols -// defined with this macro as being exported. - -#ifdef DALIWRAPPER_EXPORTS -#define DALIWRAPPER_API __declspec(dllexport) -#else -#define DALIWRAPPER_API __declspec(dllimport) -#endif - -// This class is exported from the DaliWrapper.dll -class DALIWRAPPER_API CDaliWrapper -{ - -public: - CDaliWrapper(void); - // TODO: add your methods here. - -}; - -extern DALIWRAPPER_API int nDaliWrapper; - -DALIWRAPPER_API int fnDaliWrapper(void); diff --git a/dali-csharp-binder/src/actor-wrap.cpp b/dali-csharp-binder/src/actor-wrap.cpp deleted file mode 100644 index 1b470423..00000000 --- a/dali-csharp-binder/src/actor-wrap.cpp +++ /dev/null @@ -1,3806 +0,0 @@ -/* - * Copyright (c) 2023 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -// SWIGINTERN - the relevant parts of the generated code can be seen the below. - -SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal const* self) -{ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal const* self) -{ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal* self, bool (*func)(Dali::Actor, Dali::TouchEvent const&)) -{ - self->Connect(func); -} -SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal* self, bool (*func)(Dali::Actor, Dali::TouchEvent const&)) -{ - self->Disconnect(func); -} -SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal* self, Dali::Actor arg1, Dali::TouchEvent const& arg2) -{ - return self->Emit(arg1, arg2); -} -SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal const* self) -{ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal const* self) -{ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal* self, bool (*func)(Dali::Actor, Dali::HoverEvent const&)) -{ - self->Connect(func); -} -SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal* self, bool (*func)(Dali::Actor, Dali::HoverEvent const&)) -{ - self->Disconnect(func); -} -SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal* self, Dali::Actor arg1, Dali::HoverEvent const& arg2) -{ - return self->Emit(arg1, arg2); -} -SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal const* self) -{ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal const* self) -{ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal* self, bool (*func)(Dali::Actor, Dali::WheelEvent const&)) -{ - self->Connect(func); -} -SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal* self, bool (*func)(Dali::Actor, Dali::WheelEvent const&)) -{ - self->Disconnect(func); -} -SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal* self, Dali::Actor arg1, Dali::WheelEvent const& arg2) -{ - return self->Emit(arg1, arg2); -} -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal const* self) -{ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal const* self) -{ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal* self, void (*func)(Dali::Actor)) -{ - self->Connect(func); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal* self, void (*func)(Dali::Actor)) -{ - self->Disconnect(func); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal* self, Dali::Actor arg) -{ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; - /*@SWIG@*/ self->Emit(arg); -} - -using namespace Dali; - -#ifdef __cplusplus -extern "C" { -#endif - -// Property - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::PARENT_ORIGIN; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::PARENT_ORIGIN_X; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::ANCHOR_POINT; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::ANCHOR_POINT_X; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::ANCHOR_POINT_Y; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::ANCHOR_POINT_Z; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::SIZE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::SIZE_WIDTH; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::SIZE_HEIGHT; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::SIZE_DEPTH; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::POSITION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::POSITION_X; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::POSITION_Y; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::POSITION_Z; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::WORLD_POSITION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::WORLD_POSITION_X; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::WORLD_POSITION_Y; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::WORLD_POSITION_Z; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::ORIENTATION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::WORLD_ORIENTATION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::SCALE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::SCALE_X; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::SCALE_Y; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::SCALE_Z; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::WORLD_SCALE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::VISIBLE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::COLOR; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::COLOR_RED; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::COLOR_GREEN; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::COLOR_BLUE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::COLOR_ALPHA; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::WORLD_COLOR; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::WORLD_MATRIX; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::NAME; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::SENSITIVE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_USER_INTERACTION_ENABLED_get() -{ - int jresult; - int result; - - result = (int)Dali::DevelActor::Property::USER_INTERACTION_ENABLED; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::LEAVE_REQUIRED; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::INHERIT_ORIENTATION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::INHERIT_SCALE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::COLOR_MODE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::DRAW_MODE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::PADDING; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::MINIMUM_SIZE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::MAXIMUM_SIZE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::INHERIT_POSITION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::CLIPPING_MODE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_UPDATE_AREA_HINT_get() -{ - int jresult; - int result; - - result = (int)Dali::Actor::Property::UPDATE_AREA_HINT; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() -{ - return Dali::Actor::Property::OPACITY; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() -{ - return Dali::Actor::Property::SCREEN_POSITION; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() -{ - return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() -{ - return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() -{ - return Dali::Actor::Property::LAYOUT_DIRECTION; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CULLED_get() -{ - return Dali::Actor::Property::CULLED; -} - -// Creation - -SWIGEXPORT Dali::Handle* SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor* jarg1) -{ - return (Dali::Handle*)jarg1; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Actor_Property() -{ - void* jresult; - Dali::Actor::Property* result = 0; - - { - try - { - result = (Dali::Actor::Property*)new Dali::Actor::Property(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void* jarg1) -{ - Dali::Actor::Property* arg1 = (Dali::Actor::Property*)0; - - arg1 = (Dali::Actor::Property*)jarg1; - { - try - { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() -{ - void* jresult; - Dali::Actor* result = 0; - - { - try - { - result = (Dali::Actor*)new Dali::Actor(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_New() -{ - void* jresult; - Dali::Actor result; - - { - try - { - result = Dali::Actor::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_DownCast(void* jarg1) -{ - void* jresult; - Dali::BaseHandle arg1; - Dali::BaseHandle* argp1; - Dali::Actor 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::Actor::DownCast(arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor&)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void* jarg1) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - - arg1 = (Dali::Actor*)jarg1; - { - try - { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = 0; - Dali::Actor* result = 0; - - arg1 = (Dali::Actor*)jarg1; - if(!arg1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Actor*)new Dali::Actor((Dali::Actor const&)*arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_Assign(void* jarg1, void* jarg2) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Actor* arg2 = 0; - Dali::Actor* result = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - if(!jarg2) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Actor*)jarg2; - { - try - { - result = (Dali::Actor*)&(arg1)->operator=((Dali::Actor const&)*arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -// Method - -SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Actor_GetName(void* jarg1) -{ - char* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - std::string* result = 0; - std::string name = ""; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - name = ((Dali::Actor const*)arg1)->GetProperty(Dali::Actor::Property::NAME); - result = (std::string*)&name; - jresult = SWIG_csharp_string_callback(result->c_str()); - } - CALL_CATCH_EXCEPTION(0); - } - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void* jarg1, char* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - std::string* arg2 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - if(!jarg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try - { - (arg1)->SetProperty(Dali::Actor::Property::NAME, (std::string const&)*arg2); - } - CALL_CATCH_EXCEPTION(); - } - - //argout typemap for const std::string& -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void* jarg1) -{ - unsigned int jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - unsigned int result; - - arg1 = (Dali::Actor*)jarg1; - - if(!arg1) - { - DALI_LOG_ERROR("[ERROR] actor is null! return -1"); - return -1; - } - - { - try - { - result = (unsigned int)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::ID); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void* jarg1) -{ - bool jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - bool result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (bool)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::IS_ROOT); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_OnStage(void* jarg1) -{ - bool jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - bool result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (bool)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::CONNECTED_TO_SCENE); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void* jarg1) -{ - bool jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - bool result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (bool)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::IS_LAYER); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Layer result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (arg1)->GetLayer(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Layer((const Dali::Layer&)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void* jarg1, void* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Actor arg2; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - if(!jarg2) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = *((Dali::Actor*)jarg2); - { - try - { - (arg1)->Add(arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void* jarg1, void* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Actor arg2; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - if(!jarg2) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = *((Dali::Actor*)jarg2); - { - try - { - (arg1)->Remove(arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void* jarg1) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - (arg1)->Unparent(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void* jarg1) -{ - unsigned int jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - unsigned int result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (unsigned int)((Dali::Actor const*)arg1)->GetChildCount(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void* jarg1, unsigned int jarg2) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - unsigned int arg2; - Dali::Actor result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (unsigned int)jarg2; - { - try - { - result = ((Dali::Actor const*)arg1)->GetChildAt(arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void* jarg1, char* jarg2) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - std::string* arg2 = 0; - Dali::Actor result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - if(!jarg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try - { - result = (arg1)->FindChildByName((std::string const&)*arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor&)result); - - //argout typemap for const std::string& - - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void* jarg1, unsigned int jarg2) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - unsigned int arg2; - Dali::Actor result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (unsigned int)jarg2; - { - try - { - result = (arg1)->FindChildById(arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetParent(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Actor result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = ((Dali::Actor const*)arg1)->GetParent(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor&)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void* jarg1, void* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector3* arg2 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Vector3*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return; - } - { - try - { - (arg1)->SetProperty(Actor::Property::PARENT_ORIGIN, (Dali::Vector3 const&)*arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector3 result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::PARENT_ORIGIN); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3&)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void* jarg1, void* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector3* arg2 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Vector3*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return; - } - { - try - { - (arg1)->SetProperty(Actor::Property::ANCHOR_POINT, (Dali::Vector3 const&)*arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector3 result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::ANCHOR_POINT); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3&)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void* jarg1, float jarg2, float jarg3) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - float arg2; - float arg3; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - { - try - { - (arg1)->SetProperty(Actor::Property::SIZE, Dali::Vector2(arg2, arg3)); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void* jarg1, float jarg2, float jarg3, float jarg4) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - float arg2; - float arg3; - float arg4; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - { - try - { - (arg1)->SetProperty(Actor::Property::SIZE, Dali::Vector3(arg2, arg3, arg4)); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void* jarg1, void* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector2* arg2 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Vector2*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return; - } - { - try - { - (arg1)->SetProperty(Actor::Property::SIZE, (Dali::Vector2 const&)*arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void* jarg1, void* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector3* arg2 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Vector3*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return; - } - { - try - { - (arg1)->SetProperty(Actor::Property::SIZE, (Dali::Vector3 const&)*arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector3 result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = ((Dali::Actor const*)arg1)->GetTargetSize(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector3 result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::SIZE); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector3 result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = ((Dali::Actor const*)arg1)->GetNaturalSize(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3&)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void* jarg1, float jarg2, float jarg3) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - float arg2; - float arg3; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - { - try - { - (arg1)->SetProperty(Actor::Property::POSITION, Dali::Vector2(arg2, arg3)); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void* jarg1, float jarg2, float jarg3, float jarg4) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - float arg2; - float arg3; - float arg4; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - { - try - { - (arg1)->SetProperty(Actor::Property::POSITION, Dali::Vector3(arg2, arg3, arg4)); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void* jarg1, void* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector3* arg2 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Vector3*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return; - } - { - try - { - (arg1)->SetProperty(Actor::Property::POSITION, (Dali::Vector3 const&)*arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void* jarg1, float jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - float arg2; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (float)jarg2; - { - try - { - (arg1)->SetProperty(Actor::Property::POSITION_X, (arg2)); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void* jarg1, float jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - float arg2; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (float)jarg2; - { - try - { - (arg1)->SetProperty(Actor::Property::POSITION_Y, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void* jarg1, float jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - float arg2; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (float)jarg2; - { - try - { - (arg1)->SetProperty(Actor::Property::POSITION_Z, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void* jarg1, void* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector3* arg2 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Vector3*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return; - } - { - try - { - (arg1)->TranslateBy((Dali::Vector3 const&)*arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector3 result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::POSITION); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector3 result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::WORLD_POSITION); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3&)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void* jarg1, bool jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - bool arg2; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = jarg2 ? true : false; - { - try - { - (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void* jarg1) -{ - bool jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - bool result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (bool)((Dali::Actor const*)arg1)->GetProperty(Dali::Actor::Property::INHERIT_POSITION); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void* jarg1, void* jarg2, void* jarg3) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Degree* arg2 = 0; - Dali::Vector3* arg3 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Degree*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0); - return; - } - arg3 = (Dali::Vector3*)jarg3; - if(!arg3) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return; - } - { - try - { - (arg1)->SetProperty(Actor::Property::ORIENTATION, Quaternion((Dali::Degree const&)*arg2, (Dali::Vector3 const&)*arg3)); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void* jarg1, void* jarg2, void* jarg3) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Radian* arg2 = 0; - Dali::Vector3* arg3 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Radian*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0); - return; - } - arg3 = (Dali::Vector3*)jarg3; - if(!arg3) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return; - } - { - try - { - (arg1)->SetProperty(Actor::Property::ORIENTATION, Quaternion((Dali::Radian const&)*arg2, (Dali::Vector3 const&)*arg3)); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void* jarg1, void* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Quaternion* arg2 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Quaternion*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return; - } - { - try - { - (arg1)->SetProperty(Actor::Property::ORIENTATION, (Dali::Quaternion const&)*arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void* jarg1, void* jarg2, void* jarg3) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Degree* arg2 = 0; - Dali::Vector3* arg3 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Degree*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0); - return; - } - arg3 = (Dali::Vector3*)jarg3; - if(!arg3) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return; - } - { - try - { - (arg1)->RotateBy((Dali::Degree const&)*arg2, (Dali::Vector3 const&)*arg3); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void* jarg1, void* jarg2, void* jarg3) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Radian* arg2 = 0; - Dali::Vector3* arg3 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Radian*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0); - return; - } - arg3 = (Dali::Vector3*)jarg3; - if(!arg3) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return; - } - { - try - { - (arg1)->RotateBy((Dali::Radian const&)*arg2, (Dali::Vector3 const&)*arg3); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void* jarg1, void* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Quaternion* arg2 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Quaternion*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return; - } - { - try - { - (arg1)->RotateBy((Dali::Quaternion const&)*arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Quaternion result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::ORIENTATION); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Quaternion((const Dali::Quaternion&)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void* jarg1, bool jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - bool arg2; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = jarg2 ? true : false; - { - try - { - (arg1)->SetProperty(Actor::Property::INHERIT_ORIENTATION, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void* jarg1) -{ - bool jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - bool result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (bool)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::INHERIT_ORIENTATION); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Quaternion result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::WORLD_ORIENTATION); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Quaternion((const Dali::Quaternion&)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void* jarg1, float jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - float arg2; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (float)jarg2; - { - try - { - (arg1)->SetProperty(Actor::Property::SCALE, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void* jarg1, float jarg2, float jarg3, float jarg4) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - float arg2; - float arg3; - float arg4; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - { - try - { - (arg1)->SetProperty(Actor::Property::SCALE, Vector3(arg2, arg3, arg4)); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void* jarg1, void* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector3* arg2 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Vector3*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return; - } - { - try - { - (arg1)->SetProperty(Actor::Property::SCALE, (Dali::Vector3 const&)*arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void* jarg1, void* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector3* arg2 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Vector3*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return; - } - { - try - { - (arg1)->ScaleBy((Dali::Vector3 const&)*arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector3 result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::SCALE); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector3 result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::WORLD_SCALE); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3&)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void* jarg1, bool jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - bool arg2; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = jarg2 ? true : false; - { - try - { - (arg1)->SetProperty(Actor::Property::INHERIT_SCALE, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void* jarg1) -{ - bool jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - bool result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (bool)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::INHERIT_SCALE); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Matrix result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::WORLD_MATRIX); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Matrix((const Dali::Matrix&)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void* jarg1) -{ - Dali::Actor arg1; - Dali::Actor* argp1; - - argp1 = (Dali::Actor*)jarg1; - if(!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return; - } - arg1 = *argp1; - { - try - { - arg1.Raise(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void* jarg1) -{ - Dali::Actor arg1; - Dali::Actor* argp1; - - argp1 = (Dali::Actor*)jarg1; - if(!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return; - } - arg1 = *argp1; - { - try - { - arg1.Lower(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void* jarg1) -{ - Dali::Actor arg1; - Dali::Actor* argp1; - - argp1 = (Dali::Actor*)jarg1; - if(!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return; - } - arg1 = *argp1; - { - try - { - arg1.RaiseToTop(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void* jarg1) -{ - Dali::Actor arg1; - Dali::Actor* argp1; - - argp1 = (Dali::Actor*)jarg1; - if(!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return; - } - arg1 = *argp1; - { - try - { - arg1.LowerToBottom(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void* jarg1, void* jarg2) -{ - Dali::Actor arg1; - Dali::Actor arg2; - Dali::Actor* argp1; - Dali::Actor* argp2; - - argp1 = (Dali::Actor*)jarg1; - if(!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return; - } - arg1 = *argp1; - argp2 = (Dali::Actor*)jarg2; - if(!argp2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return; - } - arg2 = *argp2; - { - try - { - arg1.RaiseAbove(arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void* jarg1, void* jarg2) -{ - Dali::Actor arg1; - Dali::Actor arg2; - Dali::Actor* argp1; - Dali::Actor* argp2; - - argp1 = (Dali::Actor*)jarg1; - if(!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return; - } - arg1 = *argp1; - argp2 = (Dali::Actor*)jarg2; - if(!argp2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return; - } - arg2 = *argp2; - { - try - { - arg1.LowerBelow(arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void* jarg1, bool jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - bool arg2; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = jarg2 ? true : false; - { - try - { - (arg1)->SetProperty(Actor::Property::VISIBLE, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void* jarg1) -{ - bool jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - bool result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (bool)((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::VISIBLE); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void* jarg1, float jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - float arg2; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (float)jarg2; - { - try - { - (arg1)->SetProperty(Actor::Property::OPACITY, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void* jarg1) -{ - float jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - float result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (float)((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::OPACITY); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void* jarg1, void* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector4* arg2 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Vector4*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return; - } - { - try - { - (arg1)->SetProperty(Actor::Property::COLOR, (Dali::Vector4 const&)*arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector4 result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::COLOR); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4&)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void* jarg1, int jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::ColorMode arg2; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::ColorMode)jarg2; - { - try - { - (arg1)->SetProperty(Actor::Property::COLOR_MODE, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void* jarg1) -{ - int jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::ColorMode result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (Dali::ColorMode)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::COLOR_MODE); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector4 result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = ((Dali::Actor const*)arg1)->GetCurrentProperty(Actor::Property::WORLD_COLOR); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4&)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void* jarg1, int jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::DrawMode::Type arg2; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::DrawMode::Type)jarg2; - { - try - { - (arg1)->SetProperty(Actor::Property::DRAW_MODE, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void* jarg1) -{ - int jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::DrawMode::Type result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (Dali::DrawMode::Type)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::DRAW_MODE); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void* jarg1, bool jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - bool arg2; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = jarg2 ? true : false; - { - try - { - (arg1)->SetProperty(Actor::Property::SENSITIVE, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void* jarg1) -{ - bool jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - bool result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (bool)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::SENSITIVE); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void* jarg1, float* jarg2, float* jarg3, float jarg4, float jarg5) -{ - bool jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - float* arg2 = 0; - float* arg3 = 0; - float arg4; - float arg5; - bool result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (float*)jarg2; - arg3 = (float*)jarg3; - arg4 = (float)jarg4; - arg5 = (float)jarg5; - { - try - { - result = (bool)((Dali::Actor const*)arg1)->ScreenToLocal(*arg2, *arg3, arg4, arg5); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void* jarg1, bool jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - bool arg2; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = jarg2 ? true : false; - { - try - { - (arg1)->SetProperty(Actor::Property::LEAVE_REQUIRED, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void* jarg1) -{ - bool jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - bool result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (bool)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::LEAVE_REQUIRED); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void* jarg1, bool jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - bool arg2; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = jarg2 ? true : false; - { - try - { - (arg1)->SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void* jarg1) -{ - bool jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - bool result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (bool)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::KEYBOARD_FOCUSABLE); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusableChildren(void* actor, bool keyboardFocusableChildren) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - - if(!actor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return; - } - - arg1 = (Dali::Actor*)actor; - { - try - { - (arg1)->SetProperty(DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN, keyboardFocusableChildren); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_AreChildrenKeyBoardFocusable(void* actor) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - bool result; - - if(!actor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return 0; - } - - arg1 = (Dali::Actor*)actor; - { - try - { - result = (bool)((Dali::Actor const*)arg1)->GetProperty(DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN); - } - CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetTouchFocusable(void* jarg1, bool jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - bool arg2; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = jarg2 ? true : false; - { - try - { - (arg1)->SetProperty(DevelActor::Property::TOUCH_FOCUSABLE, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsTouchFocusable(void* jarg1) -{ - bool jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - bool result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (bool)((Dali::Actor const*)arg1)->GetProperty(DevelActor::Property::TOUCH_FOCUSABLE); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void* jarg1, int jarg2, int jarg3) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::ResizePolicy::Type arg2; - Dali::Dimension::Type arg3; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::ResizePolicy::Type)jarg2; - arg3 = (Dali::Dimension::Type)jarg3; - { - try - { - (arg1)->SetResizePolicy(arg2, arg3); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void* jarg1, int jarg2) -{ - int jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Dimension::Type arg2; - Dali::ResizePolicy::Type result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Dimension::Type)jarg2; - { - try - { - result = (Dali::ResizePolicy::Type)((Dali::Actor const*)arg1)->GetResizePolicy(arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void* jarg1, int jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::SizeScalePolicy::Type arg2; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::SizeScalePolicy::Type)jarg2; - { - try - { - (arg1)->SetProperty(Actor::Property::SIZE_SCALE_POLICY, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void* jarg1) -{ - int jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::SizeScalePolicy::Type result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (Dali::SizeScalePolicy::Type)((Dali::Actor const*)arg1)->GetProperty(Actor::Property::SIZE_SCALE_POLICY); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void* jarg1, void* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector3* arg2 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Vector3*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return; - } - { - try - { - (arg1)->SetProperty(Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const&)*arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector3 result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = ((Dali::Actor const*)arg1)->GetProperty(Actor::Property::SIZE_MODE_FACTOR); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3&)result); - return jresult; -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void* jarg1, float jarg2) -{ - float jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - float arg2; - float result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (float)jarg2; - { - try - { - result = (float)(arg1)->GetHeightForWidth(arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void* jarg1, float jarg2) -{ - float jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - float arg2; - float result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (float)jarg2; - { - try - { - result = (float)(arg1)->GetWidthForHeight(arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void* jarg1, int jarg2) -{ - float jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Dimension::Type arg2; - float result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Dimension::Type)jarg2; - { - try - { - result = (float)((Dali::Actor const*)arg1)->GetRelayoutSize(arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void* jarg1, void* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Padding* arg2 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Padding*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0); - return; - } - { - try - { - (arg1)->SetProperty(Actor::Property::PADDING, (Dali::Padding const&)*arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void* jarg1, void* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Padding* arg2 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Padding*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0); - return; - } - { - try - { - *arg2 = ((Dali::Actor const*)arg1)->GetProperty(Actor::Property::PADDING); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void* jarg1, void* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector2* arg2 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Vector2*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return; - } - { - try - { - (arg1)->SetProperty(Actor::Property::MINIMUM_SIZE, (Dali::Vector2 const&)*arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector2 result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (arg1)->GetProperty(Actor::Property::MINIMUM_SIZE); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2&)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void* jarg1, void* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector2* arg2 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Vector2*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return; - } - { - try - { - (arg1)->SetProperty(Actor::Property::MAXIMUM_SIZE, (Dali::Vector2 const&)*arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void* jarg1) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Vector2 result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (arg1)->GetProperty(Actor::Property::MAXIMUM_SIZE); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2&)result); - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void* jarg1) -{ - int jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - int result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (int)(arg1)->GetProperty(Actor::Property::HIERARCHY_DEPTH); - Dali::Actor parent = ((Dali::Actor const*)arg1)->GetParent(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void* jarg1, void* jarg2) -{ - unsigned int jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Renderer* arg2 = 0; - unsigned int result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Renderer*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0); - return 0; - } - { - try - { - result = (unsigned int)(arg1)->AddRenderer(*arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void* jarg1) -{ - unsigned int jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - unsigned int result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - { - try - { - result = (unsigned int)((Dali::Actor const*)arg1)->GetRendererCount(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void* jarg1, unsigned int jarg2) -{ - void* jresult; - Dali::Actor* arg1 = (Dali::Actor*)0; - unsigned int arg2; - Dali::Renderer result; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return 0; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (unsigned int)jarg2; - { - try - { - result = (arg1)->GetRendererAt(arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Renderer((const Dali::Renderer&)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void* jarg1, void* jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - Dali::Renderer* arg2 = 0; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (Dali::Renderer*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0); - return; - } - { - try - { - (arg1)->RemoveRenderer(*arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void* jarg1, unsigned int jarg2) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - unsigned int arg2; - - if(!jarg1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!"); - return; - } - - arg1 = (Dali::Actor*)jarg1; - arg2 = (unsigned int)jarg2; - { - try - { - (arg1)->RemoveRenderer(arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetNeedGesturePropagation(void* jarg1, bool jarg2) -{ - Dali::Actor arg1; - bool arg2; - Dali::Actor* argp1 = (Dali::Actor*)0; - - argp1 = (Dali::Actor*)jarg1; - if(!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return; - } - arg1 = *argp1; - arg2 = jarg2; - { - try - { - Dali::DevelActor::SetNeedGesturePropagation(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_CalculateScreenPosition(void* actor) -{ - void* jresult; - Dali::Actor arg1; - Dali::Actor* argp1 = (Dali::Actor*)0; - Dali::Vector2 result; - - argp1 = (Dali::Actor*)actor; - if(!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg1 = *argp1; - { - try - { - result = Dali::DevelActor::CalculateScreenPosition(arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_CalculateScreenExtents(void* actor) -{ - Dali::Actor arg1; - Dali::Actor* argp1 = (Dali::Actor*)0; - Dali::Rect result; - - argp1 = (Dali::Actor*)actor; - if(!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg1 = *argp1; - { - try - { - result = Dali::DevelActor::CalculateScreenExtents(arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - // Note: The float type Rectangle class is not ready yet. - // Therefore, it transmits data in Vector4 class. - // This type should later be changed to the appropriate data type. - return new Dali::Vector4(result.x, result.y, result.width, result.height); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_CurrentScreenExtents(void* actor) -{ - Dali::Actor arg1; - Dali::Actor* argp1 = (Dali::Actor*)0; - Dali::Rect result; - - argp1 = (Dali::Actor*)actor; - if(!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg1 = *argp1; - { - try - { - result = Dali::DevelActor::CalculateCurrentScreenExtents(arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - // Note: The float type Rectangle class is not ready yet. - // Therefore, it transmits data in Vector4 class. - // This type should later be changed to the appropriate data type. - return new Dali::Vector4(result.x, result.y, result.width, result.height); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_LookAt(void* csActor, void* csTarget, void* csUp, void* csLocalForward, void* csLocalUp) -{ - Dali::Actor actor; - Dali::Vector3 target; - Dali::Vector3 up = Vector3::YAXIS; - Dali::Vector3 localForward = Vector3::ZAXIS; - Dali::Vector3 localUp = Vector3::YAXIS; - - if(!csActor) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return; - } - - if(!csTarget) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null target Dali::Vector3", 0); - return; - } - - actor = *(Dali::Actor*)csActor; - target = *(Dali::Vector3*)csTarget; - - // Use default value if csUp is null - if(csUp) - { - up = *(Dali::Vector3*)csUp; - } - - // Use default value if csLocalForward is null - if(csLocalForward) - { - localForward = *(Dali::Vector3*)csLocalForward; - } - - // Use default value if csLocalForward is null - if(csLocalUp) - { - localUp = *(Dali::Vector3*)csLocalUp; - } - - { - try - { - Dali::DevelActor::LookAt(actor, target, up, localForward, localUp); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_SetTouchAreaOffset(void* jarg1, int jarg2, int jarg3, int jarg4, int jarg5) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - arg1 = (Dali::Actor*)jarg1; - Rect arg2 = Rect(jarg2, jarg3, jarg4, jarg5); - { - try - { - (arg1)->SetProperty(Dali::DevelActor::Property::TOUCH_AREA_OFFSET, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_GetTouchAreaOffset(void* jarg1, int* jarg2, int* jarg3, int* jarg4, int* jarg5) -{ - Dali::Actor* arg1 = (Dali::Actor*)0; - arg1 = (Dali::Actor*)jarg1; - - Rect result; - { - try - { - result = (arg1)->GetProperty>(Dali::DevelActor::Property::TOUCH_AREA_OFFSET); - *jarg2 = result.left; - *jarg3 = result.right; - *jarg4 = result.bottom; - *jarg5 = result.top; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void* jarg1) -{ - Dali::Actor* arg1 = 0; - - arg1 = (Dali::Actor*)jarg1; - if(!arg1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); - return; - } - { - try - { - Dali::UnparentAndReset(*arg1); - } - CALL_CATCH_EXCEPTION(); - } -} - -// Signals -#ifndef GENERATE_DEVEL_ACTOR_SIGNAL -#define GENERATE_DEVEL_ACTOR_SIGNAL(HType, SignalName) GENERATE_DEVEL_SIGNAL(Dali::Actor*, HType, Dali::DevelActor, Dali_Actor, SignalName) -#endif -#ifndef GENERATE_ACTOR_SIGNAL -#define GENERATE_ACTOR_SIGNAL(HType, SignalName) GENERATE_SIGNAL(Dali::Actor*, HType, Dali_Actor, SignalName) -#endif - -GENERATE_DEVEL_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::TouchEvent const&), HitTestResultSignal) -// CSharp_Dali_Actor_HitTestResultSignal_Connect -// CSharp_Dali_Actor_HitTestResultSignal_Disconnect - -GENERATE_DEVEL_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::TouchEvent const&), InterceptTouchedSignal) -// CSharp_Dali_Actor_InterceptTouchedSignal_Connect -// CSharp_Dali_Actor_InterceptTouchedSignal_Disconnect - -GENERATE_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::TouchEvent const&), TouchedSignal) -// CSharp_Dali_Actor_TouchedSignal_Connect -// CSharp_Dali_Actor_TouchedSignal_Disconnect - -GENERATE_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::HoverEvent const&), HoveredSignal) -// CSharp_Dali_Actor_HoveredSignal_Connect -// CSharp_Dali_Actor_HoveredSignal_Disconnect - -GENERATE_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::WheelEvent const&), WheelEventSignal) -// CSharp_Dali_Actor_WheelEventSignal_Connect -// CSharp_Dali_Actor_WheelEventSignal_Disconnect - -GENERATE_DEVEL_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::WheelEvent const&), InterceptWheelSignal) -// CSharp_Dali_Actor_InterceptWheelSignal_Connect -// CSharp_Dali_Actor_InterceptWheelSignal_Disconnect - -GENERATE_ACTOR_SIGNAL(void(*)(Dali::Actor), OnSceneSignal) -// CSharp_Dali_Actor_OnSceneSignal_Connect -// CSharp_Dali_Actor_OnSceneSignal_Disconnect - -GENERATE_ACTOR_SIGNAL(void(*)(Dali::Actor), OffSceneSignal) -// CSharp_Dali_Actor_OffSceneSignal_Connect -// CSharp_Dali_Actor_OffSceneSignal_Disconnect - -GENERATE_ACTOR_SIGNAL(void(*)(Dali::Actor), OnRelayoutSignal) -// CSharp_Dali_Actor_OnRelayoutSignal_Connect -// CSharp_Dali_Actor_OnRelayoutSignal_Disconnect - -GENERATE_DEVEL_ACTOR_SIGNAL(void(*)(Dali::Actor, bool, Dali::DevelActor::VisibilityChange::Type), VisibilityChangedSignal) -// CSharp_Dali_Actor_VisibilityChangedSignal_Connect -// CSharp_Dali_Actor_VisibilityChangedSignal_Disconnect - -GENERATE_ACTOR_SIGNAL(void(*)(Dali::Actor, LayoutDirection::Type), LayoutDirectionChangedSignal) -// CSharp_Dali_Actor_LayoutDirectionChangedSignal_Connect -// CSharp_Dali_Actor_LayoutDirectionChangedSignal_Disconnect - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/adaptor-wrap.cpp b/dali-csharp-binder/src/adaptor-wrap.cpp deleted file mode 100755 index 9c7c4544..00000000 --- a/dali-csharp-binder/src/adaptor-wrap.cpp +++ /dev/null @@ -1,128 +0,0 @@ -/* - * Copyright (c) 2020 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Adaptor &) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Adaptor &) > const *self){ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Adaptor &) > *self,void (*func)(Dali::Adaptor &)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Adaptor &) > *self,void (*func)(Dali::Adaptor &)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Adaptor_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Adaptor &) > *self,Dali::Adaptor &arg){ - self->Emit( arg ); -} - -#ifdef __cplusplus -extern "C" { -#endif - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Adaptor(void * jarg1) { - Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ; - - arg1 = (Dali::Adaptor *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_SetRenderRefreshRate(void * jarg1, unsigned int jarg2) { - Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Adaptor *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - (arg1)->SetRenderRefreshRate(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Adaptor_Get() { - void * jresult ; - Dali::Adaptor *result = 0 ; - - { - try { - result = (Dali::Adaptor *) &Dali::Adaptor::Get(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_FeedWheelEvent(void * jarg1, void * jarg2) { - Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ; - Dali::WheelEvent *arg2 = 0 ; - - arg1 = (Dali::Adaptor *)jarg1; - arg2 = (Dali::WheelEvent *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent & type is null", 0); - return ; - } - { - try { - (arg1)->FeedWheelEvent(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_FeedKeyEvent(void * jarg1, void * jarg2) { - Dali::Adaptor *arg1 = (Dali::Adaptor *) 0 ; - Dali::KeyEvent *arg2 = 0 ; - - arg1 = (Dali::Adaptor *)jarg1; - arg2 = (Dali::KeyEvent *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent & type is null", 0); - return ; - } - { - try { - (arg1)->FeedKeyEvent(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/animation-wrap.cpp b/dali-csharp-binder/src/animation-wrap.cpp deleted file mode 100755 index 0cf06c96..00000000 --- a/dali-csharp-binder/src/animation-wrap.cpp +++ /dev/null @@ -1,1613 +0,0 @@ -/* - * Copyright (c) 2017 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - -// EXTERNAL INCLUDES -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){ -return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){ - self->Emit( arg ); -} - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() { - void * jresult ; - Dali::Animation *result = 0 ; - - { - try { - result = (Dali::Animation *)new Dali::Animation(); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) { - void * jresult ; - float arg1 ; - Dali::Animation result; - - arg1 = (float)jarg1; - { - try { - result = Dali::Animation::New(arg1); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = new Dali::Animation((const Dali::Animation &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Animation 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::Animation::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = new Dali::Animation((const Dali::Animation &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - - arg1 = (Dali::Animation *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Animation *arg1 = 0 ; - Dali::Animation *result = 0 ; - - arg1 = (Dali::Animation *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - Dali::Animation *arg2 = 0 ; - Dali::Animation *result = 0 ; - - arg1 = (Dali::Animation *)jarg1; - arg2 = (Dali::Animation *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - float arg2 ; - - arg1 = (Dali::Animation *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetDuration(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) { - float jresult ; - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - float result; - - arg1 = (Dali::Animation *)jarg1; - { - try { - result = (float)((Dali::Animation const *)arg1)->GetDuration(); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - bool arg2 ; - - arg1 = (Dali::Animation *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - (arg1)->SetLooping(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - int arg2 ; - - arg1 = (Dali::Animation *)jarg1; - arg2 = (int)jarg2; - { - try { - (arg1)->SetLoopCount(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) { - int jresult ; - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - int result; - - arg1 = (Dali::Animation *)jarg1; - { - try { - result = (int)(arg1)->GetLoopCount(); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) { - int jresult ; - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - int result; - - arg1 = (Dali::Animation *)jarg1; - { - try { - result = (int)(arg1)->GetCurrentLoop(); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) { - unsigned int jresult ; - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - bool result; - - arg1 = (Dali::Animation *)jarg1; - { - try { - result = (bool)((Dali::Animation const *)arg1)->IsLooping(); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - Dali::Animation::EndAction arg2 ; - - arg1 = (Dali::Animation *)jarg1; - arg2 = (Dali::Animation::EndAction)jarg2; - { - try { - (arg1)->SetEndAction(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) { - int jresult ; - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - Dali::Animation::EndAction result; - - arg1 = (Dali::Animation *)jarg1; - { - try { - result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction(); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - Dali::Animation::EndAction arg2 ; - - arg1 = (Dali::Animation *)jarg1; - arg2 = (Dali::Animation::EndAction)jarg2; - { - try { - (arg1)->SetDisconnectAction(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) { - int jresult ; - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - Dali::Animation::EndAction result; - - arg1 = (Dali::Animation *)jarg1; - { - try { - result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction(); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - Dali::AlphaFunction arg2 ; - Dali::AlphaFunction *argp2 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::AlphaFunction *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetDefaultAlphaFunction(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) { - void * jresult ; - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - Dali::AlphaFunction result; - - arg1 = (Dali::Animation *)jarg1; - { - try { - result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction(); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - float arg2 ; - - arg1 = (Dali::Animation *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetCurrentProgress(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) { - float jresult ; - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - float result; - - arg1 = (Dali::Animation *)jarg1; - { - try { - result = (float)(arg1)->GetCurrentProgress(); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - float arg2 ; - - arg1 = (Dali::Animation *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetSpeedFactor(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) { - float jresult ; - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - float result; - - arg1 = (Dali::Animation *)jarg1; - { - try { - result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor(); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - Dali::Vector2 *arg2 = 0 ; - - arg1 = (Dali::Animation *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) { - void * jresult ; - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::Animation *)jarg1; - { - try { - result = ((Dali::Animation const *)arg1)->GetPlayRange(); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - - arg1 = (Dali::Animation *)jarg1; - { - try { - (arg1)->Play(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - float arg2 ; - - arg1 = (Dali::Animation *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->PlayFrom(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - - arg1 = (Dali::Animation *)jarg1; - { - try { - (arg1)->Pause(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) { - int jresult ; - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - Dali::Animation::State result; - - arg1 = (Dali::Animation *)jarg1; - { - try { - result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState(); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - - arg1 = (Dali::Animation *)jarg1; - { - try { - (arg1)->Stop(); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetProgressNotification(void* jarg1, float jarg2) { - Dali::Animation* argp1 = (Dali::Animation *) jarg1 ; - - Dali::Animation arg1 = *argp1; - float arg2 = (float)jarg2; - - { - try { - Dali::DevelAnimation::SetProgressNotification(arg1, arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetProgressNotification(void * jarg1) { - float jresult ; - Dali::Animation* argp1 = (Dali::Animation *) jarg1 ; - float result; - - Dali::Animation arg1 = *argp1; - { - try { - result = (float)Dali::DevelAnimation::GetProgressNotification(arg1); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetBlendPoint(void* csAnimation, float blendPoint) { - Dali::Animation* animation = (Dali::Animation *) csAnimation ; - - { - try { - animation->SetBlendPoint(blendPoint); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetBlendPoint(void * csAnimation) { - Dali::Animation* animation = (Dali::Animation *) csAnimation ; - float result; - - { - try { - result = animation->GetBlendPoint(); - } CALL_CATCH_EXCEPTION(0); - - } - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - - arg1 = (Dali::Animation *)jarg1; - { - try { - (arg1)->Clear(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopingMode(void * jarg1, int jarg2) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - Dali::Animation::LoopingMode arg2 ; - - arg1 = (Dali::Animation *)jarg1; - arg2 = (Dali::Animation::LoopingMode)jarg2; - { - try { - (arg1)->SetLoopingMode(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopingMode(void * jarg1) { - int jresult ; - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - Dali::Animation::LoopingMode result; - - arg1 = (Dali::Animation *)jarg1; - { - try { - result = (Dali::Animation::LoopingMode)((Dali::Animation const *)arg1)->GetLoopingMode(); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) { - void * jresult ; - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - Dali::Animation::AnimationSignalType *result = 0 ; - - arg1 = (Dali::Animation *)jarg1; - { - try { - result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal(); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_ProgressReachedSignal(void * jarg1) { - void * jresult ; - Dali::Animation* argp1 = (Dali::Animation*) jarg1 ; - Dali::Animation::AnimationSignalType *result = 0 ; - - Dali::Animation arg1 = *argp1; - { - try { - result = (Dali::Animation::AnimationSignalType* ) &Dali::DevelAnimation::ProgressReachedSignal(arg1); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayAfter(void * jarg1, float jarg2) { - Dali::Animation arg1 ; - float arg2 ; - Dali::Animation *argp1 ; - - argp1 = (Dali::Animation *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Animation", 0); - return ; - } - arg1 = *argp1; - arg2 = (float)jarg2; - { - try { - arg1.PlayAfter(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - Dali::Property::Value arg3 ; - Dali::Property *argp2 ; - Dali::Property::Value *argp3 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Property::Value *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); - return ; - } - arg3 = *argp3; - { - try { - (arg1)->AnimateBy(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - Dali::Property::Value arg3 ; - Dali::AlphaFunction arg4 ; - Dali::Property *argp2 ; - Dali::Property::Value *argp3 ; - Dali::AlphaFunction *argp4 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Property::Value *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); - return ; - } - arg3 = *argp3; - argp4 = (Dali::AlphaFunction *)jarg4; - if (!argp4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); - return ; - } - arg4 = *argp4; - { - try { - (arg1)->AnimateBy(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - Dali::Property::Value arg3 ; - SwigValueWrapper< Dali::TimePeriod > arg4 ; - Dali::Property *argp2 ; - Dali::Property::Value *argp3 ; - Dali::TimePeriod *argp4 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Property::Value *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); - return ; - } - arg3 = *argp3; - argp4 = (Dali::TimePeriod *)jarg4; - if (!argp4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); - return ; - } - arg4 = *argp4; - { - try { - (arg1)->AnimateBy(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - Dali::Property::Value arg3 ; - Dali::AlphaFunction arg4 ; - SwigValueWrapper< Dali::TimePeriod > arg5 ; - Dali::Property *argp2 ; - Dali::Property::Value *argp3 ; - Dali::AlphaFunction *argp4 ; - Dali::TimePeriod *argp5 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Property::Value *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); - return ; - } - arg3 = *argp3; - argp4 = (Dali::AlphaFunction *)jarg4; - if (!argp4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); - return ; - } - arg4 = *argp4; - argp5 = (Dali::TimePeriod *)jarg5; - if (!argp5) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); - return ; - } - arg5 = *argp5; - { - try { - (arg1)->AnimateBy(arg2,arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - Dali::Property::Value arg3 ; - Dali::Property *argp2 ; - Dali::Property::Value *argp3 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Property::Value *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); - return ; - } - arg3 = *argp3; - { - try { - (arg1)->AnimateTo(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - Dali::Property::Value arg3 ; - Dali::AlphaFunction arg4 ; - Dali::Property *argp2 ; - Dali::Property::Value *argp3 ; - Dali::AlphaFunction *argp4 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Property::Value *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); - return ; - } - arg3 = *argp3; - argp4 = (Dali::AlphaFunction *)jarg4; - if (!argp4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); - return ; - } - arg4 = *argp4; - { - try { - (arg1)->AnimateTo(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - Dali::Property::Value arg3 ; - SwigValueWrapper< Dali::TimePeriod > arg4 ; - Dali::Property *argp2 ; - Dali::Property::Value *argp3 ; - Dali::TimePeriod *argp4 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Property::Value *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); - return ; - } - arg3 = *argp3; - argp4 = (Dali::TimePeriod *)jarg4; - if (!argp4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); - return ; - } - arg4 = *argp4; - { - try { - (arg1)->AnimateTo(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - Dali::Property::Value arg3 ; - Dali::AlphaFunction arg4 ; - SwigValueWrapper< Dali::TimePeriod > arg5 ; - Dali::Property *argp2 ; - Dali::Property::Value *argp3 ; - Dali::AlphaFunction *argp4 ; - Dali::TimePeriod *argp5 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Property::Value *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); - return ; - } - arg3 = *argp3; - argp4 = (Dali::AlphaFunction *)jarg4; - if (!argp4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); - return ; - } - arg4 = *argp4; - argp5 = (Dali::TimePeriod *)jarg5; - if (!argp5) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); - return ; - } - arg5 = *argp5; - { - try { - (arg1)->AnimateTo(arg2,arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - Dali::KeyFrames *arg3 = 0 ; - Dali::Property *argp2 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::KeyFrames *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0); - return ; - } - { - try { - (arg1)->AnimateBetween(arg2,*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - Dali::KeyFrames *arg3 = 0 ; - Dali::Animation::Interpolation arg4 ; - Dali::Property *argp2 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::KeyFrames *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0); - return ; - } - arg4 = (Dali::Animation::Interpolation)jarg4; - { - try { - (arg1)->AnimateBetween(arg2,*arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - Dali::KeyFrames *arg3 = 0 ; - Dali::AlphaFunction arg4 ; - Dali::Property *argp2 ; - Dali::AlphaFunction *argp4 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::KeyFrames *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0); - return ; - } - argp4 = (Dali::AlphaFunction *)jarg4; - if (!argp4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); - return ; - } - arg4 = *argp4; - { - try { - (arg1)->AnimateBetween(arg2,*arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - Dali::KeyFrames *arg3 = 0 ; - Dali::AlphaFunction arg4 ; - Dali::Animation::Interpolation arg5 ; - Dali::Property *argp2 ; - Dali::AlphaFunction *argp4 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::KeyFrames *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0); - return ; - } - argp4 = (Dali::AlphaFunction *)jarg4; - if (!argp4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); - return ; - } - arg4 = *argp4; - arg5 = (Dali::Animation::Interpolation)jarg5; - { - try { - (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - Dali::KeyFrames *arg3 = 0 ; - SwigValueWrapper< Dali::TimePeriod > arg4 ; - Dali::Property *argp2 ; - Dali::TimePeriod *argp4 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::KeyFrames *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0); - return ; - } - argp4 = (Dali::TimePeriod *)jarg4; - if (!argp4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); - return ; - } - arg4 = *argp4; - { - try { - (arg1)->AnimateBetween(arg2,*arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - Dali::KeyFrames *arg3 = 0 ; - SwigValueWrapper< Dali::TimePeriod > arg4 ; - Dali::Animation::Interpolation arg5 ; - Dali::Property *argp2 ; - Dali::TimePeriod *argp4 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::KeyFrames *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0); - return ; - } - argp4 = (Dali::TimePeriod *)jarg4; - if (!argp4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); - return ; - } - arg4 = *argp4; - arg5 = (Dali::Animation::Interpolation)jarg5; - { - try { - (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - Dali::KeyFrames *arg3 = 0 ; - Dali::AlphaFunction arg4 ; - SwigValueWrapper< Dali::TimePeriod > arg5 ; - Dali::Property *argp2 ; - Dali::AlphaFunction *argp4 ; - Dali::TimePeriod *argp5 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::KeyFrames *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0); - return ; - } - argp4 = (Dali::AlphaFunction *)jarg4; - if (!argp4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); - return ; - } - arg4 = *argp4; - argp5 = (Dali::TimePeriod *)jarg5; - if (!argp5) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); - return ; - } - arg5 = *argp5; - { - try { - (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - Dali::KeyFrames *arg3 = 0 ; - Dali::AlphaFunction arg4 ; - SwigValueWrapper< Dali::TimePeriod > arg5 ; - Dali::Animation::Interpolation arg6 ; - Dali::Property *argp2 ; - Dali::AlphaFunction *argp4 ; - Dali::TimePeriod *argp5 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::KeyFrames *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0); - return ; - } - argp4 = (Dali::AlphaFunction *)jarg4; - if (!argp4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); - return ; - } - arg4 = *argp4; - argp5 = (Dali::TimePeriod *)jarg5; - if (!argp5) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); - return ; - } - arg5 = *argp5; - arg6 = (Dali::Animation::Interpolation)jarg6; - { - try { - (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - Dali::Actor arg2 ; - Dali::Path arg3 ; - Dali::Vector3 *arg4 = 0 ; - Dali::Actor *argp2 ; - Dali::Path *argp3 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Path *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0); - return ; - } - arg3 = *argp3; - arg4 = (Dali::Vector3 *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - { - try { - (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - Dali::Actor arg2 ; - Dali::Path arg3 ; - Dali::Vector3 *arg4 = 0 ; - Dali::AlphaFunction arg5 ; - Dali::Actor *argp2 ; - Dali::Path *argp3 ; - Dali::AlphaFunction *argp5 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Path *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0); - return ; - } - arg3 = *argp3; - arg4 = (Dali::Vector3 *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - argp5 = (Dali::AlphaFunction *)jarg5; - if (!argp5) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); - return ; - } - arg5 = *argp5; - { - try { - (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - Dali::Actor arg2 ; - Dali::Path arg3 ; - Dali::Vector3 *arg4 = 0 ; - SwigValueWrapper< Dali::TimePeriod > arg5 ; - Dali::Actor *argp2 ; - Dali::Path *argp3 ; - Dali::TimePeriod *argp5 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Path *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0); - return ; - } - arg3 = *argp3; - arg4 = (Dali::Vector3 *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - argp5 = (Dali::TimePeriod *)jarg5; - if (!argp5) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); - return ; - } - arg5 = *argp5; - { - try { - (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - Dali::Actor arg2 ; - Dali::Path arg3 ; - Dali::Vector3 *arg4 = 0 ; - Dali::AlphaFunction arg5 ; - SwigValueWrapper< Dali::TimePeriod > arg6 ; - Dali::Actor *argp2 ; - Dali::Path *argp3 ; - Dali::AlphaFunction *argp5 ; - Dali::TimePeriod *argp6 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Path *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0); - return ; - } - arg3 = *argp3; - arg4 = (Dali::Vector3 *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - argp5 = (Dali::AlphaFunction *)jarg5; - if (!argp5) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); - return ; - } - arg5 = *argp5; - argp6 = (Dali::TimePeriod *)jarg6; - if (!argp6) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0); - return ; - } - arg6 = *argp6; - { - try { - (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - Dali::Actor arg2 ; - float arg3 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - arg3 = (float)jarg3; - { - try { - (arg1)->Show(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) { - Dali::Animation *arg1 = (Dali::Animation *) 0 ; - Dali::Actor arg2 ; - float arg3 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Animation *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - arg3 = (float)jarg3; - { - try { - (arg1)->Hide(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ; - void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1; - arg2 = (void (*)(Dali::Animation &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ; - void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1; - arg2 = (void (*)(Dali::Animation &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ; - Dali::Animation *arg2 = 0 ; - - arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1; - arg2 = (Dali::Animation *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0); - return ; - } - { - try { - Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() { - void * jresult ; - Dali::Signal< void (Dali::Animation &) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >(); - } CALL_CATCH_EXCEPTION(0); - - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) { - Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/application-wrap.cpp b/dali-csharp-binder/src/application-wrap.cpp deleted file mode 100644 index d8ea9410..00000000 --- a/dali-csharp-binder/src/application-wrap.cpp +++ /dev/null @@ -1,1844 +0,0 @@ -/* - * Copyright (c) 2022 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -/* Callback for returning strings to C# without leaking memory */ -typedef char*(SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char*); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -namespace -{ -// keep argcs and argv so they're always available to DALi -// Note : This argments used only if argv comes externally. -int gArgC = 0; -char** gArgV = nullptr; - -void ReleaseArgVMemory() -{ - if(gArgV) - { - // free string data - for(int i = 0; i < gArgC + 1; ++i) - { - delete[] gArgV[i]; - } - delete[] gArgV; - gArgV = nullptr; - } - gArgC = 0; -} - -void GenerationArgV(int argc, char* argv) -{ - // TODO : What should we do if already generated argv exist? - ReleaseArgVMemory(); - // generate argv data from the C# args - int index = 0; - int length = 0; - char* retPtr = NULL; - char* nextPtr; - - gArgV = new char*[argc + 1]; - - for(retPtr = strtok_r(argv, " ", &nextPtr); - retPtr != NULL && index < argc; - retPtr = strtok_r(NULL, " ", &nextPtr)) - { - length = 0; - length = strlen(retPtr); - gArgV[index] = new char[length + 1]; - strncpy(gArgV[index], retPtr, length); - gArgV[index][length] = '\0'; - index++; - } - - while(index < argc) - { - //if jarg1 - index >1, maybe cause error. - gArgV[index] = NULL; - index++; - } - - gArgV[argc] = NULL; - gArgC = argc; -} - -} // unnamed namespace - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Empty(Dali::Signal const* self) -{ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__GetConnectionCount(Dali::Signal const* self) -{ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Connect(Dali::Signal* self, void (*func)(Dali::DeviceStatus::Battery::Status)) -{ - self->Connect(func); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Disconnect(Dali::Signal* self, void (*func)(Dali::DeviceStatus::Battery::Status)) -{ - self->Disconnect(func); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Emit(Dali::Signal* self, Dali::DeviceStatus::Battery::Status arg) -{ - self->Emit(arg); -} -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Empty(Dali::Signal const* self) -{ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__GetConnectionCount(Dali::Signal const* self) -{ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Connect(Dali::Signal* self, void (*func)(Dali::DeviceStatus::Memory::Status)) -{ - self->Connect(func); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Disconnect(Dali::Signal* self, void (*func)(Dali::DeviceStatus::Memory::Status)) -{ - self->Disconnect(func); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Emit(Dali::Signal* self, Dali::DeviceStatus::Memory::Status arg) -{ - self->Emit(arg); -} - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Empty(Dali::Signal const* self) -{ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__GetConnectionCount(Dali::Signal const* self) -{ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Connect(Dali::Signal* self, void (*func)(Dali::DeviceStatus::Orientation::Status)) -{ - self->Connect(func); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Disconnect(Dali::Signal* self, void (*func)(Dali::DeviceStatus::Orientation::Status)) -{ - self->Disconnect(func); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Emit(Dali::Signal* self, Dali::DeviceStatus::Orientation::Status arg) -{ - self->Emit(arg); -} - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal const* self) -{ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal const* self) -{ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal* self, void (*func)(Dali::Application&)) -{ - self->Connect(func); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal* self, void (*func)(Dali::Application&)) -{ - self->Disconnect(func); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal* self, Dali::Application& arg) -{ - self->Emit(arg); -} - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal const* self) -{ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount(Dali::Signal const* self) -{ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(Dali::Signal* self, void (*func)(Dali::Application&, void*)) -{ - self->Connect(func); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(Dali::Signal* self, void (*func)(Dali::Application&, void*)) -{ - self->Disconnect(func); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(Dali::Signal* self, Dali::Application& arg1, void* arg2) -{ - self->Emit(arg1, arg2); -} - -#ifdef __cplusplus -extern "C" { -#endif - -/*Application binding*/ -SWIGEXPORT Dali::BaseHandle* SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application* jarg1) -{ - return (Dali::BaseHandle*)jarg1; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_PreInitialize() -{ - ApplicationPreInitialize(nullptr, nullptr); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() -{ - void* jresult; - Dali::Application result; - - { - try - { - result = Dali::Application::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Application((const Dali::Application&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) -{ - void* jresult; - - Dali::Application result; - { - try - { - result = Dali::Application::New(nullptr, nullptr); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Application((const Dali::Application&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char* jarg3) -{ - void* jresult; - std::string* arg3 = 0; - - Dali::Application result; - if(!jarg3) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg3_str(jarg3); - arg3 = &arg3_str; - { - try - { - result = Dali::Application::New(nullptr, nullptr, (std::string const&)*arg3); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Application((const Dali::Application&)result); - - //argout typemap for const std::string& - - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char* jarg3, int jarg4) -{ - void* jresult; - Dali::Application::WINDOW_MODE arg4; - - Dali::Application result; - if(!jarg3) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg3(jarg3); - arg4 = (Dali::Application::WINDOW_MODE)jarg4; - { - try - { - result = Dali::Application::New(nullptr, nullptr, arg3, arg4); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Application((const Dali::Application&)result); - - //argout typemap for const std::string& - - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__MANUAL_4(int jarg1, char* jarg2, char* jarg3, int jarg4) -{ - void* jresult; - int* argc = nullptr; - char*** argv = nullptr; - Dali::Application::WINDOW_MODE arg4; - Dali::Application result; - - { - // TODO : What should we do if already generated argv exist? - ReleaseArgVMemory(); - // generate argv data from the C# args - int index = 0; - int length = 0; - char* retPtr = NULL; - char* nextPtr; - - gArgV = new char*[jarg1 + 1]; - - for(retPtr = strtok_r(jarg2, " ", &nextPtr); - retPtr != NULL && index < jarg1; - retPtr = strtok_r(NULL, " ", &nextPtr)) - { - length = 0; - length = strlen(retPtr); - gArgV[index] = new char[length + 1]; - strncpy(gArgV[index], retPtr, length); - gArgV[index][length] = '\0'; - index++; - } - - while(index < jarg1) - { - //if jarg1 - index >1, maybe cause error. - gArgV[index] = NULL; - index++; - } - - gArgV[jarg1] = NULL; - gArgC = jarg1; - - argc = &gArgC; - argv = &gArgV; - } - - std::string arg3(jarg3); - arg4 = (Dali::Application::WINDOW_MODE)jarg4; - { - try - { - result = Dali::Application::New(argc, argv, arg3, arg4); - } - CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Application((const Dali::Application&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() -{ - void* jresult; - Dali::Application* result = 0; - - { - try - { - result = (Dali::Application*)new Dali::Application(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void* jarg1) -{ - void* jresult; - Dali::Application* arg1 = 0; - Dali::Application* result = 0; - - arg1 = (Dali::Application*)jarg1; - if(!arg1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Application*)new Dali::Application((Dali::Application const&)*arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_Assign(void* jarg1, void* jarg2) -{ - void* jresult; - Dali::Application* arg1 = (Dali::Application*)0; - Dali::Application* arg2 = 0; - Dali::Application* result = 0; - - arg1 = (Dali::Application*)jarg1; - arg2 = (Dali::Application*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Application*)&(arg1)->operator=((Dali::Application const&)*arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void* jarg1) -{ - Dali::Application* arg1 = (Dali::Application*)0; - - arg1 = (Dali::Application*)jarg1; - { - try - { - delete arg1; - ReleaseArgVMemory(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void* jarg1) -{ - Dali::Application* arg1 = (Dali::Application*)0; - - arg1 = (Dali::Application*)jarg1; - { - try - { - (arg1)->MainLoop(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void* jarg1) -{ - Dali::Application* arg1 = (Dali::Application*)0; - - arg1 = (Dali::Application*)jarg1; - { - try - { - (arg1)->Lower(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void* jarg1) -{ - Dali::Application* arg1 = (Dali::Application*)0; - - arg1 = (Dali::Application*)jarg1; - { - try - { - (arg1)->Quit(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void* jarg1, void* jarg2) -{ - unsigned int jresult; - Dali::Application* arg1 = (Dali::Application*)0; - Dali::CallbackBase* arg2 = (Dali::CallbackBase*)0; - bool result; - - arg1 = (Dali::Application*)jarg1; - arg2 = (Dali::CallbackBase*)jarg2; - { - try - { - result = (bool)(arg1)->AddIdle(arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_GetWindow(void* jarg1) -{ - void* jresult; - Dali::Application* arg1 = (Dali::Application*)0; - Dali::Window result; - - arg1 = (Dali::Application*)jarg1; - { - try - { - result = (arg1)->GetWindow(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Window((const Dali::Window&)result); - return jresult; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_GetWindowsListSize() -{ - unsigned int jresult; - Dali::WindowContainer result; - { - try - { - result = Dali::Adaptor::Get().GetWindows(); - jresult = result.size(); - } - CALL_CATCH_EXCEPTION(0); - } - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_GetWindowsFromList(unsigned int jarg1) -{ - void* jresult; - unsigned int index = jarg1; - Dali::WindowContainer result; - - { - try - { - result = Dali::Adaptor::Get().GetWindows(); - } - CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Window((const Dali::Window&)result[index]); - return jresult; -} - -SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() -{ - char* jresult; - std::string result; - - { - try - { - result = Dali::Application::GetResourcePath(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback((&result)->c_str()); - return jresult; -} - -SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Application_GetRegion(void* jarg1) -{ - char* jresult; - Dali::Application* arg1 = (Dali::Application*)0; - std::string result; - - arg1 = (Dali::Application*)jarg1; - { - try - { - result = (arg1)->GetRegion(); - } - CALL_CATCH_EXCEPTION(0); - } - jresult = SWIG_csharp_string_callback((&result)->c_str()); - return jresult; -} - -SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Application_GetLanguage(void* jarg1) -{ - char* jresult; - Dali::Application* arg1 = (Dali::Application*)0; - std::string result; - - arg1 = (Dali::Application*)jarg1; - { - try - { - result = (arg1)->GetLanguage(); - } - CALL_CATCH_EXCEPTION(0); - } - jresult = SWIG_csharp_string_callback((&result)->c_str()); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_InitSignal(void* jarg1) -{ - void* jresult; - Dali::Application* arg1 = (Dali::Application*)0; - Dali::Application::AppSignalType* result = 0; - - arg1 = (Dali::Application*)jarg1; - { - try - { - result = (Dali::Application::AppSignalType*)&(arg1)->InitSignal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void* jarg1) -{ - void* jresult; - Dali::Application* arg1 = (Dali::Application*)0; - Dali::Application::AppSignalType* result = 0; - - arg1 = (Dali::Application*)jarg1; - { - try - { - result = (Dali::Application::AppSignalType*)&(arg1)->TerminateSignal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void* jarg1) -{ - void* jresult; - Dali::Application* arg1 = (Dali::Application*)0; - Dali::Application::AppSignalType* result = 0; - - arg1 = (Dali::Application*)jarg1; - { - try - { - result = (Dali::Application::AppSignalType*)&(arg1)->PauseSignal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void* jarg1) -{ - void* jresult; - Dali::Application* arg1 = (Dali::Application*)0; - Dali::Application::AppSignalType* result = 0; - - arg1 = (Dali::Application*)jarg1; - { - try - { - result = (Dali::Application::AppSignalType*)&(arg1)->ResumeSignal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void* jarg1) -{ - void* jresult; - Dali::Application* arg1 = (Dali::Application*)0; - Dali::Application::AppSignalType* result = 0; - - arg1 = (Dali::Application*)jarg1; - { - try - { - result = (Dali::Application::AppSignalType*)&(arg1)->ResetSignal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void* jarg1) -{ - void* jresult; - Dali::Application* arg1 = (Dali::Application*)0; - Dali::Application::AppControlSignalType* result = 0; - - arg1 = (Dali::Application*)jarg1; - { - try - { - result = (Dali::Application::AppControlSignalType*)&(arg1)->AppControlSignal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void* jarg1) -{ - void* jresult; - Dali::Application* arg1 = (Dali::Application*)0; - Dali::Application::AppSignalType* result = 0; - - arg1 = (Dali::Application*)jarg1; - { - try - { - result = (Dali::Application::AppSignalType*)&(arg1)->LanguageChangedSignal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void* jarg1) -{ - void* jresult; - Dali::Application* arg1 = (Dali::Application*)0; - Dali::Application::AppSignalType* result = 0; - - arg1 = (Dali::Application*)jarg1; - { - try - { - result = (Dali::Application::AppSignalType*)&(arg1)->RegionChangedSignal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_LowBatterySignal(void* jarg1) -{ - void* jresult; - Dali::Application* arg1 = (Dali::Application*)0; - Dali::Application::LowBatterySignalType* result = 0; - - arg1 = (Dali::Application*)jarg1; - { - try - { - result = (Dali::Application::LowBatterySignalType*)&(arg1)->LowBatterySignal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_LowMemorySignal(void* jarg1) -{ - void* jresult; - Dali::Application* arg1 = (Dali::Application*)0; - Dali::Application::LowMemorySignalType* result = 0; - - arg1 = (Dali::Application*)jarg1; - { - try - { - result = (Dali::Application::LowMemorySignalType*)&(arg1)->LowMemorySignal(); - } - CALL_CATCH_EXCEPTION(0); - } - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignal(void* jarg1) -{ - void* jresult; - Dali::Application* arg1 = (Dali::Application*)0; - Dali::Application::DeviceOrientationChangedSignalType* result = 0; - - arg1 = (Dali::Application*)jarg1; - { - try - { - result = (Dali::Application::DeviceOrientationChangedSignalType*)&(arg1)->DeviceOrientationChangedSignal(); - } - CALL_CATCH_EXCEPTION(0); - } - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskInitSignal(void* app) -{ - void* jresult; - Dali::Application* application = (Dali::Application*)0; - Dali::Application::AppSignalType* result = 0; - - application = (Dali::Application*)app; - { - try - { - result = (Dali::Application::AppSignalType*)&(application)->TaskInitSignal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskTerminateSignal(void* app) -{ - void* jresult; - Dali::Application* application = (Dali::Application*)0; - Dali::Application::AppSignalType* result = 0; - - application = (Dali::Application*)app; - { - try - { - result = (Dali::Application::AppSignalType*)&(application)->TaskTerminateSignal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskAppControlSignal(void* app) -{ - void* jresult; - Dali::Application* application = (Dali::Application*)0; - Dali::Application::AppControlSignalType* result = 0; - - application = (Dali::Application*)app; - { - try - { - result = (Dali::Application::AppControlSignalType*)&(application)->TaskAppControlSignal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskLanguageChangedSignal(void* app) -{ - void* jresult; - Dali::Application* application = (Dali::Application*)0; - Dali::Application::AppSignalType* result = 0; - - application = (Dali::Application*)app; - { - try - { - result = (Dali::Application::AppSignalType*)&(application)->TaskLanguageChangedSignal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskRegionChangedSignal(void* app) -{ - void* jresult; - Dali::Application* application = (Dali::Application*)0; - Dali::Application::AppSignalType* result = 0; - - application = (Dali::Application*)app; - { - try - { - result = (Dali::Application::AppSignalType*)&(application)->TaskRegionChangedSignal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskLowBatterySignal(void* app) -{ - void* jresult; - Dali::Application* application = (Dali::Application*)0; - Dali::Application::LowBatterySignalType* result = 0; - - application = (Dali::Application*)app; - { - try - { - result = (Dali::Application::LowBatterySignalType*)&(application)->TaskLowBatterySignal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskLowMemorySignal(void* app) -{ - void* jresult; - Dali::Application* application = (Dali::Application*)0; - Dali::Application::LowMemorySignalType* result = 0; - - application = (Dali::Application*)app; - { - try - { - result = (Dali::Application::LowMemorySignalType*)&(application)->TaskLowMemorySignal(); - } - CALL_CATCH_EXCEPTION(0); - } - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_TaskDeviceOrientationChangedSignal(void* app) -{ - void* jresult; - Dali::Application* application = (Dali::Application*)0; - Dali::Application::DeviceOrientationChangedSignalType* result = 0; - - application = (Dali::Application*)app; - { - try - { - result = (Dali::Application::DeviceOrientationChangedSignalType*)&(application)->TaskDeviceOrientationChangedSignal(); - } - CALL_CATCH_EXCEPTION(0); - } - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Empty(void* jarg1) -{ - unsigned int jresult; - Dali::Signal* arg1 = (Dali::Signal*)0; - bool result; - - arg1 = (Dali::Signal*)jarg1; - { - try - { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Empty((Dali::Signal const*)arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_GetConnectionCount(void* jarg1) -{ - unsigned long jresult; - Dali::Signal* arg1 = (Dali::Signal*)0; - std::size_t result; - - arg1 = (Dali::Signal*)jarg1; - { - try - { - result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__GetConnectionCount((Dali::Signal const*)arg1); - } - CALL_CATCH_EXCEPTION(0); - } - jresult = (unsigned long)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Connect(void* jarg1, void* jarg2) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - void (*arg2)(Dali::DeviceStatus::Battery::Status) = (void (*)(Dali::DeviceStatus::Battery::Status))0; - - arg1 = (Dali::Signal*)jarg1; - arg2 = (void (*)(Dali::DeviceStatus::Battery::Status))jarg2; - { - try - { - Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Connect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Disconnect(void* jarg1, void* jarg2) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - void (*arg2)(Dali::DeviceStatus::Battery::Status) = (void (*)(Dali::DeviceStatus::Battery::Status))0; - - arg1 = (Dali::Signal*)jarg1; - arg2 = (void (*)(Dali::DeviceStatus::Battery::Status))jarg2; - { - try - { - Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Disconnect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowBatterySignalType_Emit(void* jarg1, void* jarg2) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - Dali::DeviceStatus::Battery::Status arg2; - Dali::DeviceStatus::Battery::Status* argp2; - - arg1 = (Dali::Signal*)jarg1; - argp2 = (Dali::DeviceStatus::Battery::Status*)jarg2; - if(!argp2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DeviceStatus::Battery::Status", 0); - return; - } - arg2 = *argp2; - { - try - { - Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Battery_Status_SP__Sg__Emit(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_new_LowBatterySignalType() -{ - void* jresult; - Dali::Signal* result = 0; - - { - try - { - result = (Dali::Signal*)new Dali::Signal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_LowBatterySignalType(void* jarg1) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - - arg1 = (Dali::Signal*)jarg1; - { - try - { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Empty(void* jarg1) -{ - unsigned int jresult; - Dali::Signal* arg1 = (Dali::Signal*)0; - bool result; - - arg1 = (Dali::Signal*)jarg1; - { - try - { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Empty((Dali::Signal const*)arg1); - } - CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_GetConnectionCount(void* jarg1) -{ - unsigned long jresult; - Dali::Signal* arg1 = (Dali::Signal*)0; - std::size_t result; - - arg1 = (Dali::Signal*)jarg1; - { - try - { - result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__GetConnectionCount((Dali::Signal const*)arg1); - } - CALL_CATCH_EXCEPTION(0); - } - jresult = (unsigned long)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Connect(void* jarg1, void* jarg2) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - void (*arg2)(Dali::DeviceStatus::Memory::Status) = (void (*)(Dali::DeviceStatus::Memory::Status))0; - - arg1 = (Dali::Signal*)jarg1; - arg2 = (void (*)(Dali::DeviceStatus::Memory::Status))jarg2; - { - try - { - Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Connect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Disconnect(void* jarg1, void* jarg2) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - void (*arg2)(Dali::DeviceStatus::Memory::Status) = (void (*)(Dali::DeviceStatus::Memory::Status))0; - - arg1 = (Dali::Signal*)jarg1; - arg2 = (void (*)(Dali::DeviceStatus::Memory::Status))jarg2; - { - try - { - Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Disconnect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_LowMemorySignalType_Emit(void* jarg1, void* jarg2) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - Dali::DeviceStatus::Memory::Status arg2; - Dali::DeviceStatus::Memory::Status* argp2; - - arg1 = (Dali::Signal*)jarg1; - argp2 = (Dali::DeviceStatus::Memory::Status*)jarg2; - if(!argp2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DeviceStatus::Memory::Status", 0); - return; - } - arg2 = *argp2; - { - try - { - Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Memory_Status_SP__Sg__Emit(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_new_LowMemorySignalType() -{ - void* jresult; - Dali::Signal* result = 0; - - { - try - { - result = (Dali::Signal*)new Dali::Signal(); - } - CALL_CATCH_EXCEPTION(0); - } - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_LowMemorySignalType(void* jarg1) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - - arg1 = (Dali::Signal*)jarg1; - { - try - { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_Empty(void* jarg1) -{ - unsigned int jresult; - Dali::Signal* arg1 = (Dali::Signal*)0; - bool result; - - arg1 = (Dali::Signal*)jarg1; - { - try - { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Empty((Dali::Signal const*)arg1); - } - CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_GetConnectionCount(void* jarg1) -{ - unsigned long jresult; - Dali::Signal* arg1 = (Dali::Signal*)0; - std::size_t result; - - arg1 = (Dali::Signal*)jarg1; - { - try - { - result = Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__GetConnectionCount((Dali::Signal const*)arg1); - } - CALL_CATCH_EXCEPTION(0); - } - jresult = (unsigned long)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_Connect(void* jarg1, void* jarg2) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - void (*arg2)(Dali::DeviceStatus::Orientation::Status) = (void (*)(Dali::DeviceStatus::Orientation::Status))0; - - arg1 = (Dali::Signal*)jarg1; - arg2 = (void (*)(Dali::DeviceStatus::Orientation::Status))jarg2; - { - try - { - Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Connect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_Disconnect(void* jarg1, void* jarg2) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - void (*arg2)(Dali::DeviceStatus::Orientation::Status) = (void (*)(Dali::DeviceStatus::Orientation::Status))0; - - arg1 = (Dali::Signal*)jarg1; - arg2 = (void (*)(Dali::DeviceStatus::Orientation::Status))jarg2; - { - try - { - Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Disconnect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_DeviceOrientationChangedSignalType_Emit(void* jarg1, void* jarg2) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - Dali::DeviceStatus::Orientation::Status arg2; - Dali::DeviceStatus::Orientation::Status* argp2; - - arg1 = (Dali::Signal*)jarg1; - argp2 = (Dali::DeviceStatus::Orientation::Status*)jarg2; - if(!argp2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DeviceStatus::Orientation::Status", 0); - return; - } - arg2 = *argp2; - { - try - { - Dali_Signal_Sl_void_Sp_Dali_DeviceStatus_Orientation_Status_SP__Sg__Emit(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_new_DeviceOrientationChangedSignalType() -{ - void* jresult; - Dali::Signal* result = 0; - - { - try - { - result = (Dali::Signal*)new Dali::Signal(); - } - CALL_CATCH_EXCEPTION(0); - } - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_delete_DeviceOrientationChangedSignalType(void* jarg1) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - - arg1 = (Dali::Signal*)jarg1; - { - try - { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void* jarg1) -{ - unsigned int jresult; - Dali::Signal* arg1 = (Dali::Signal*)0; - bool result; - - arg1 = (Dali::Signal*)jarg1; - { - try - { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal const*)arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void* jarg1) -{ - unsigned long jresult; - Dali::Signal* arg1 = (Dali::Signal*)0; - std::size_t result; - - arg1 = (Dali::Signal*)jarg1; - { - try - { - result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal const*)arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void* jarg1, void* jarg2) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - void (*arg2)(Dali::Application&) = (void (*)(Dali::Application&))0; - - arg1 = (Dali::Signal*)jarg1; - arg2 = (void (*)(Dali::Application&))jarg2; - { - try - { - Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void* jarg1, void* jarg2) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - void (*arg2)(Dali::Application&) = (void (*)(Dali::Application&))0; - - arg1 = (Dali::Signal*)jarg1; - arg2 = (void (*)(Dali::Application&))jarg2; - { - try - { - Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void* jarg1, void* jarg2) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - Dali::Application* arg2 = 0; - - arg1 = (Dali::Signal*)jarg1; - arg2 = (Dali::Application*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0); - return; - } - { - try - { - Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1, *arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() -{ - void* jresult; - Dali::Signal* result = 0; - - { - try - { - result = (Dali::Signal*)new Dali::Signal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void* jarg1) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - - arg1 = (Dali::Signal*)jarg1; - { - try - { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void* jarg1) -{ - unsigned int jresult; - Dali::Signal* arg1 = (Dali::Signal*)0; - bool result; - - arg1 = (Dali::Signal*)jarg1; - { - try - { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal const*)arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void* jarg1) -{ - unsigned long jresult; - Dali::Signal* arg1 = (Dali::Signal*)0; - std::size_t result; - - arg1 = (Dali::Signal*)jarg1; - { - try - { - result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal const*)arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void* jarg1, void* jarg2) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - void (*arg2)(Dali::Application&, void*) = (void (*)(Dali::Application&, void*))0; - - arg1 = (Dali::Signal*)jarg1; - arg2 = (void (*)(Dali::Application&, void*))jarg2; - { - try - { - Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void* jarg1, void* jarg2) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - void (*arg2)(Dali::Application&, void*) = (void (*)(Dali::Application&, void*))0; - - arg1 = (Dali::Signal*)jarg1; - arg2 = (void (*)(Dali::Application&, void*))jarg2; - { - try - { - Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void* jarg1, void* jarg2, void* jarg3) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - Dali::Application* arg2 = 0; - void* arg3 = (void*)0; - - arg1 = (Dali::Signal*)jarg1; - arg2 = (Dali::Application*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0); - return; - } - arg3 = jarg3; - { - try - { - Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1, *arg2, arg3); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() -{ - void* jresult; - Dali::Signal* result = 0; - - { - try - { - result = (Dali::Signal*)new Dali::Signal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void* jarg1) -{ - Dali::Signal* arg1 = (Dali::Signal*)0; - - arg1 = (Dali::Signal*)jarg1; - { - try - { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } -} - -/*application-devel binding*/ - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_4(int jarg1, char* jarg3, int jarg4, void* jarg5) -{ - void* jresult; - int* argc = nullptr; - char*** argv = nullptr; - Dali::Application::WINDOW_MODE arg4; - Dali::PositionSize arg5; - Dali::PositionSize* argp5; - Dali::Application result; - - if(!jarg3) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg3(jarg3); - arg4 = (Dali::Application::WINDOW_MODE)jarg4; - argp5 = (Dali::PositionSize*)jarg5; - if(!argp5) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0); - return 0; - } - arg5 = *argp5; - { - try - { - result = Dali::Application::New(argc, argv, arg3, arg4, arg5); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Application((const Dali::Application&)result); - - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_5(int jarg1, char* jarg3, int jarg4, void* jarg5, int jarg6) -{ - void* jresult; - int* argc = nullptr; - char*** argv = nullptr; - Dali::Application::WINDOW_MODE arg4; - Dali::PositionSize arg5; - Dali::PositionSize* argp5; - Dali::WindowType arg6; - Dali::Application result; - - if(!jarg3) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg3(jarg3); - arg4 = (Dali::Application::WINDOW_MODE)jarg4; - argp5 = (Dali::PositionSize*)jarg5; - arg6 = (Dali::WindowType)jarg6; - - if(!argp5) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0); - return 0; - } - arg5 = *argp5; - { - try - { - result = Dali::DevelApplication::New(argc, argv, arg3, arg4, arg5, arg6); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Application((const Dali::Application&)result); - - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New__SWIG_6(int nuiArgc, char* nuiArgv, char* nuiStyleSheet, int nuiWindowMode, void* nuiPositionSize, bool nuiUseUiThread) -{ - void* jresult; - int* argc = nullptr; - char*** argv = nullptr; - Dali::Application::WINDOW_MODE windowMode; - Dali::PositionSize positionSize; - Dali::PositionSize* positionSizeP; - bool useUiThread; - Dali::Application result; - - if(!nuiStyleSheet) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string styleSheet(nuiStyleSheet); - windowMode = (Dali::Application::WINDOW_MODE)nuiWindowMode; - positionSizeP = (Dali::PositionSize*)nuiPositionSize; - useUiThread = nuiUseUiThread; - - if(!positionSizeP) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0); - return 0; - } - - GenerationArgV(nuiArgc, nuiArgv); - argc = &gArgC; - argv = &gArgV; - - positionSize = *positionSizeP; - { - try - { - result = Dali::Application::New(argc, argv, styleSheet, windowMode, positionSize, useUiThread); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Application((const Dali::Application&)result); - - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New_WithWindowSizePosition(int jarg1, char* jarg2, char* jarg3, int jarg4, void* jarg5) -{ - void* jresult; - int* argc = nullptr; - char*** argv = nullptr; - Dali::Application::WINDOW_MODE arg4; - Dali::PositionSize arg5; - Dali::PositionSize* argp5; - Dali::Application result; - - { - // TODO : What should we do if already generated argv exist? - ReleaseArgVMemory(); - // generate argv data from the C# args - int index = 0; - int length = 0; - char* retPtr = NULL; - char* nextPtr; - - gArgV = new char*[jarg1 + 1]; - - for(retPtr = strtok_r(jarg2, " ", &nextPtr); - retPtr != NULL && index < jarg1; - retPtr = strtok_r(NULL, " ", &nextPtr)) - { - length = 0; - length = strlen(retPtr); - gArgV[index] = new char[length + 1]; - strncpy(gArgV[index], retPtr, length); - gArgV[index][length] = '\0'; - index++; - } - - while(index < jarg1) - { - //if jarg1 - index >1, maybe cause error. - gArgV[index] = NULL; - index++; - } - - gArgV[jarg1] = NULL; - gArgC = jarg1; - - argc = &gArgC; - argv = &gArgV; - } - - std::string arg3(jarg3); - arg4 = (Dali::Application::WINDOW_MODE)jarg4; - argp5 = (Dali::PositionSize*)jarg5; - if(!argp5) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0); - return 0; - } - arg5 = *argp5; - { - try - { - result = Dali::Application::New(argc, argv, arg3, arg4, arg5); - } - CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Application((const Dali::Application&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Application_New_WithWindowData(int nuiArgc, char* nuiArgv, char* nuiStyleSheet, bool nuiUIThread, void* nuiWindowData) -{ - void* jresult; - int* argc = nullptr; - char*** argv = nullptr; - Dali::WindowData* pWindowData; - Dali::Application result; - - { - // TODO : What should we do if already generated argv exist? - ReleaseArgVMemory(); - // generate argv data from the C# args - int index = 0; - int length = 0; - char* retPtr = NULL; - char* nextPtr; - - gArgV = new char*[nuiArgc + 1]; - - for(retPtr = strtok_r(nuiArgv, " ", &nextPtr); - retPtr != NULL && index < nuiArgc; - retPtr = strtok_r(NULL, " ", &nextPtr)) - { - length = 0; - length = strlen(retPtr); - gArgV[index] = new char[length + 1]; - strncpy(gArgV[index], retPtr, length); - gArgV[index][length] = '\0'; - index++; - } - - while(index < nuiArgc) - { - // if nuiArgc - index >1, maybe cause error. - gArgV[index] = NULL; - index++; - } - - gArgV[nuiArgc] = NULL; - gArgC = nuiArgc; - - argc = &gArgC; - argv = &gArgV; - } - - std::string styleSheet(nuiStyleSheet); - pWindowData = (Dali::WindowData*)nuiWindowData; - if(!pWindowData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0); - return 0; - } - - { - try - { - result = Dali::Application::New(argc, argv, styleSheet, nuiUIThread, *pWindowData); - } - CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Application((const Dali::Application&)result); - return jresult; -} - -SWIGEXPORT int32_t SWIGSTDCALL CSharp_Dali_Application_GetRenderThreadId(void* jarg1) -{ - Dali::Application* arg1 = (Dali::Application*)jarg1; - - int32_t result; - try - { - result = Dali::DevelApplication::GetRenderThreadId(*arg1); - } - CALL_CATCH_EXCEPTION(0); - return result; -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/atspi-wrap.cpp b/dali-csharp-binder/src/atspi-wrap.cpp deleted file mode 100755 index 5766fb17..00000000 --- a/dali-csharp-binder/src/atspi-wrap.cpp +++ /dev/null @@ -1,158 +0,0 @@ -/* - * Copyright (c) 2019 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -#define NAMEOF(x) #x - -#ifdef __cplusplus -extern "C" { -#endif - -using callbackFuncType = void(*)(int); -callbackFuncType callBack; - -void sayTestCallback(std::string result) -{ - DALI_LOG_ERROR("sayTestCallback() result=%s ", result.c_str()); - - if(callBack) - { - if(result == "ReadingCancelled") - { - callBack(1); - } - else if(result == "ReadingStopped") - { - callBack(2); - } - else if(result == "ReadingSkipped") - { - callBack(3); - } - else if(result == "ReadingPaused") - { - callBack(4); - } - else if(result == "ReadingResumed") - { - callBack(5); - } - else - { - callBack(-1); - } - } -} - -SWIGEXPORT void SWIGSTDCALL csharp_dali_accessibility_say(char* arg1_text, bool arg2_discardable, void *arg3_callback) -{ - callBack = (callbackFuncType)arg3_callback; - - Dali::AtspiAccessibility::Say(std::string{arg1_text}, arg2_discardable, sayTestCallback); -} - -SWIGEXPORT void SWIGSTDCALL csharp_dali_accessibility_pause_resume(bool arg1_pause) -{ - if(arg1_pause) - { - Dali::AtspiAccessibility::Pause(); - } - else - { - Dali::AtspiAccessibility::Resume(); - } -} - -SWIGEXPORT void SWIGSTDCALL csharp_dali_accessibility_stop_reading(bool arg1_alsoNonDiscardable) -{ - Dali::AtspiAccessibility::StopReading(arg1_alsoNonDiscardable); -} - -SWIGEXPORT bool SWIGSTDCALL csharp_dali_accessibility_suppress_screen_reader(bool arg1_suppress) -{ - return Dali::AtspiAccessibility::SuppressScreenReader(arg1_suppress); -} - -SWIGEXPORT void SWIGSTDCALL csharp_dali_accessibility_BridgeEnableAutoInit() -{ - Dali::Accessibility::Bridge::EnableAutoInit(); -} - -SWIGEXPORT void SWIGSTDCALL csharp_dali_accessibility_BridgeDisableAutoInit() -{ - Dali::Accessibility::Bridge::DisableAutoInit(); -} - -SWIGEXPORT bool SWIGSTDCALL csharp_dali_accessibility_IsEnabled() -{ - return Dali::AtspiAccessibility::IsEnabled(); -} - -SWIGEXPORT bool SWIGSTDCALL csharp_dali_accessibility_IsScreenReaderEnabled() -{ - return Dali::AtspiAccessibility::IsScreenReaderEnabled(); -} - -SWIGEXPORT void SWIGSTDCALL csharp_dali_accessibility_RegisterEnabledDisabledSignalHandler(void (*enabledSignalHandler)(), void (*disabledSignalHandler)()) -{ - using Dali::Accessibility::Bridge; - - if (!enabledSignalHandler) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Signal handler is null", NAMEOF(enabledSignalHandler)); - return; - } - - if (!disabledSignalHandler) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Signal handler is null", NAMEOF(disabledSignalHandler)); - return; - } - - Bridge::EnabledSignal().Connect(enabledSignalHandler); - Bridge::DisabledSignal().Connect(disabledSignalHandler); -} - -SWIGEXPORT void SWIGSTDCALL csharp_dali_accessibility_RegisterScreenReaderEnabledDisabledSignalHandler(void (*screenReaderEnabledSignalHandler)(), void (*screenReaderDisabledSignalHandler)()) -{ - using Dali::Accessibility::Bridge; - - if (!screenReaderEnabledSignalHandler) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Signal handler is null", NAMEOF(screenReaderEnabledSignalHandler)); - return; - } - - if (!screenReaderDisabledSignalHandler) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Signal handler is null", NAMEOF(screenReaderDisabledSignalHandler)); - return; - } - - Bridge::ScreenReaderEnabledSignal().Connect(screenReaderEnabledSignalHandler); - Bridge::ScreenReaderDisabledSignal().Connect(screenReaderDisabledSignalHandler); -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/callbackbase-wrap.cpp b/dali-csharp-binder/src/callbackbase-wrap.cpp deleted file mode 100755 index d7e4de8b..00000000 --- a/dali-csharp-binder/src/callbackbase-wrap.cpp +++ /dev/null @@ -1,46 +0,0 @@ -/* - * 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. - * - */ - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MakeCallback(void * jarg1) { - void * jresult ; - void (*arg1)(void) = (void (*)(void)) 0 ; - Dali::CallbackBase *result = 0 ; - - arg1 = (void (*)(void))jarg1; - { - try { - result = (Dali::CallbackBase *)Dali::MakeCallback(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - - jresult = (void *)result; - - return jresult; -} - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/canvas-view-wrap.cpp b/dali-csharp-binder/src/canvas-view-wrap.cpp deleted file mode 100644 index 8b8b24b5..00000000 --- a/dali-csharp-binder/src/canvas-view-wrap.cpp +++ /dev/null @@ -1,1654 +0,0 @@ -/* - * Copyright (c) 2022 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include -#include -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -using namespace Dali; -using namespace Dali::Toolkit; - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void *SWIGSTDCALL -CSharp_Dali_CanvasView_New__SWIG_0(char *pViewBox) { - Dali::ImageDimensions viewBox; - Dali::Toolkit::CanvasView result; - - if (!pViewBox) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - viewBox = *(Dali::ImageDimensions *)pViewBox; - { - try { - result = Dali::Toolkit::CanvasView::New( - Vector2(viewBox.GetWidth(), viewBox.GetHeight())); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Toolkit::CanvasView( - (const Dali::Toolkit::CanvasView &)result); -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_CanvasView_New__SWIG_1() { - Dali::Toolkit::CanvasView result; - - { - try { - result = Dali::Toolkit::CanvasView::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Toolkit::CanvasView( - (const Dali::Toolkit::CanvasView &)result); -} - -SWIGEXPORT bool SWIGSTDCALL -CSharp_Dali_CanvasView_AddDrawable(char *pCanvasView, char *pDrawable) { - Dali::Toolkit::CanvasView canvasView; - Dali::CanvasRenderer::Drawable drawable; - bool result = true; - - if (!pCanvasView) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::Toolkit::CanvasView", 0); - return false; - } - canvasView = *(Dali::Toolkit::CanvasView *)pCanvasView; - - if (!pDrawable) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); - return false; - } - drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; - { - try { - canvasView.AddDrawable(drawable); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL -CSharp_Dali_CanvasView_RemoveDrawable(char *pCanvasView, char *pDrawable) { - Dali::Toolkit::CanvasView canvasView; - Dali::CanvasRenderer::Drawable drawable; - bool result = true; - - if (!pCanvasView) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::Toolkit::CanvasView", 0); - return false; - } - canvasView = *(Dali::Toolkit::CanvasView *)pCanvasView; - - if (!pDrawable) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); - return false; - } - drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; - { - try { - canvasView.RemoveDrawable(drawable); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_CanvasView_RemoveAllDrawables(char *pCanvasView) { - Dali::Toolkit::CanvasView canvasView; - Dali::CanvasRenderer::Drawable drawable; - - if (!pCanvasView) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::Toolkit::CanvasView", 0); - return; - } - canvasView = *(Dali::Toolkit::CanvasView *)pCanvasView; - - { - try { - canvasView.RemoveAllDrawables(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CanvasView(void *pCanvasView) { - Dali::Toolkit::CanvasView *pTargetCanvasView = nullptr; - - if (!pCanvasView) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::Toolkit::CanvasView", 0); - } - - pTargetCanvasView = (Dali::Toolkit::CanvasView *)pCanvasView; - { - try { - if (pTargetCanvasView) { - delete pTargetCanvasView; - } - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CanvasView_Property_VIEWBOX_get() { - return (int)Toolkit::CanvasView::Property::VIEW_BOX; -} - -// Dali::CanvasRenderer::Drawable Wrapper - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Drawable_SetOpacity(char *pDrawable, - float opacity) { - Dali::CanvasRenderer::Drawable drawable; - - if (!pDrawable) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); - return; - } - drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; - - { - try { - drawable.SetOpacity(opacity); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Drawable_GetOpacity(char *pDrawable) { - Dali::CanvasRenderer::Drawable drawable; - float opacity = 0.0f; - - if (!pDrawable) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); - return 0.0; - } - drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; - { - try { - opacity = drawable.GetOpacity(); - } - CALL_CATCH_EXCEPTION(0); - } - - return opacity; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_Translate(char *pDrawable, - float x, float y) { - Dali::CanvasRenderer::Drawable drawable; - bool result = false; - - if (!pDrawable) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); - return false; - } - drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; - { - try { - result = drawable.Translate(Vector2(x, y)); - } - CALL_CATCH_EXCEPTION(false); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_Scale(char *pDrawable, - float scale) { - Dali::CanvasRenderer::Drawable drawable; - bool result = false; - - if (!pDrawable) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); - return false; - } - drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; - - { - try { - result = drawable.Scale(scale); - } - CALL_CATCH_EXCEPTION(false); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_Rotate(char *pDrawable, - float degree) { - Dali::CanvasRenderer::Drawable drawable; - bool result = false; - - if (!pDrawable) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); - return false; - } - drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; - { - try { - result = drawable.Rotate(Dali::Degree(degree)); - } - CALL_CATCH_EXCEPTION(false); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_Transform(char *pDrawable, - float *pTransform) { - Dali::CanvasRenderer::Drawable drawable; - bool result = false; - - if (!pDrawable) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); - return false; - } - drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; - - if (!pTransform) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, - "Dali::Matrix3 const & type is null", - 0); - return false; - } - - { - try { - result = drawable.Transform( - Dali::Matrix3(pTransform[0], pTransform[1], pTransform[2], - pTransform[3], pTransform[4], pTransform[5], - pTransform[6], pTransform[7], pTransform[8])); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void *SWIGSTDCALL -CSharp_Dali_Drawable_GetBoundingBox(char *pDrawable) { - Dali::CanvasRenderer::Drawable drawable; - Dali::Rect result; - - if (!pDrawable) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return 0; - } - drawable = *(Dali::CanvasRenderer::Shape *)pDrawable; - { - try { - result = drawable.GetBoundingBox(); - } - CALL_CATCH_EXCEPTION(0); - } - - // Note: The float type Rectangle class is not ready yet. - // Therefore, it transmits data in Vector4 class. - // This type should later be changed to the appropriate data type. - return new Dali::Vector4(result.x, result.y, result.width, result.height); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_SetClipPath(char *pDrawable, - char *pClip) { - Dali::CanvasRenderer::Drawable drawable; - Dali::CanvasRenderer::Drawable clip; - bool result = false; - - if (!pDrawable) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); - return false; - } - drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; - - if (!pClip) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); - return false; - } - clip = *(Dali::CanvasRenderer::Drawable *)pClip; - - { - try { - result = drawable.SetClipPath(clip); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_SetMask(char *pDrawable, - char *pMask, - int maskType) { - Dali::CanvasRenderer::Drawable drawable; - Dali::CanvasRenderer::Drawable mask; - bool result = false; - - if (!pDrawable) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); - return false; - } - drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; - - if (!pMask) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); - return false; - } - mask = *(Dali::CanvasRenderer::Drawable *)pMask; - - { - try { - result = drawable.SetMask( - mask, - static_cast(maskType)); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -// Dali::CanvasRenderer::Picture Wrapper - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Picture_New() { - Dali::CanvasRenderer::Picture picture; - - { - try { - picture = Dali::CanvasRenderer::Picture::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::CanvasRenderer::Picture( - (const Dali::CanvasRenderer::Picture &)picture); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Picture_Load(char *pPicture, - char *pUrl) { - Dali::CanvasRenderer::Picture picture; - bool result = false; - - if (!pPicture) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Picture", 0); - return false; - } - picture = *(Dali::CanvasRenderer::Picture *)pPicture; - - if (!pUrl) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, - "Attempt to dereference null string", - 0); - return false; - } - std::string url(pUrl); - - { - try { - result = picture.Load(url); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Picture_SetSize(char *pPicture, - void *pSize) { - Dali::CanvasRenderer::Picture picture; - bool result = false; - - if (!pPicture) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Picture", 0); - return false; - } - picture = *(Dali::CanvasRenderer::Picture *)pPicture; - - if (!pSize) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::Vector2", 0); - return false; - } - - { - try { - result = picture.SetSize(*(Dali::Vector2 *)pSize); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Picture_GetSize(char *pPicture) { - Dali::CanvasRenderer::Picture picture; - Dali::Vector2 result; - - if (!pPicture) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Picture", 0); - return nullptr; - } - picture = *(Dali::CanvasRenderer::Picture *)pPicture; - - { - try { - result = picture.GetSize(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Vector2((const Dali::Vector2 &)result); -} - -// Dali::CanvasRenderer::Shape Wrapper - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Shape_New() { - Dali::CanvasRenderer::Shape shape; - - { - try { - shape = Dali::CanvasRenderer::Shape::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::CanvasRenderer::Shape( - (const Dali::CanvasRenderer::Shape &)shape); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddRect(char *pShape, float x, - float y, float width, - float height, - float roundX, - float roundY) { - Dali::CanvasRenderer::Shape shape; - bool result = false; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return false; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - result = shape.AddRect(Rect(x, y, width, height), - Vector2(roundX, roundY)); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddCircle(char *pShape, float x, - float y, float radiusX, - float radiusY) { - Dali::CanvasRenderer::Shape shape; - bool result = false; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return false; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - result = shape.AddCircle(Vector2(x, y), Vector2(radiusX, radiusY)); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddArc(char *pShape, float x, - float y, float radius, - float startAngle, - float sweep, bool pie) { - Dali::CanvasRenderer::Shape shape; - bool result = false; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return false; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - result = shape.AddArc(Vector2(x, y), radius, startAngle, sweep, pie); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddMoveTo(char *pShape, float x, - float y) { - Dali::CanvasRenderer::Shape shape; - bool result = false; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return false; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - result = shape.AddMoveTo(Vector2(x, y)); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddLineTo(char *pShape, float x, - float y) { - Dali::CanvasRenderer::Shape shape; - bool result = false; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return false; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - result = shape.AddLineTo(Vector2(x, y)); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddCubicTo( - char *pShape, float controlPoint1X, float controlPoint1Y, - float controlPoint2X, float controlPoint2Y, float endPointX, - float endPointY) { - Dali::CanvasRenderer::Shape shape; - bool result = false; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return false; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - result = shape.AddCubicTo(Vector2(controlPoint1X, controlPoint1Y), - Vector2(controlPoint2X, controlPoint2Y), - Vector2(endPointX, endPointY)); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddPath(char *pShape, - int *pCommands, - unsigned int commandCount, - float *pPoints, - unsigned int pointCount) { - Dali::CanvasRenderer::Shape shape; - bool result = false; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return false; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - if (!pCommands) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Commands", 0); - return false; - } - - if (!pPoints) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, - "Attempt to dereference null Points", - 0); - return false; - } - - { - try { - Dali::CanvasRenderer::Shape::PathCommands pathCommands = { - (Dali::CanvasRenderer::Shape::PathCommandType *)pCommands, - commandCount, pPoints, pointCount}; - - result = shape.AddPath(pathCommands); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_Close(char *pShape) { - Dali::CanvasRenderer::Shape shape; - bool result = false; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return false; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - result = shape.Close(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_ResetPath(char *pShape) { - Dali::CanvasRenderer::Shape shape; - bool result = false; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return false; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - result = shape.ResetPath(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetFillColor(char *pShape, - char *pColor) { - Dali::CanvasRenderer::Shape shape; - Dali::Vector4 color; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - if (!pColor) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, - "Dali::Vector4 const & type is null", - 0); - return; - } - color = *(Dali::Vector4 *)pColor; - - { - try { - shape.SetFillColor(color); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Shape_GetFillColor(char *pShape) { - Dali::CanvasRenderer::Shape shape; - Dali::Vector4 result; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return 0; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - result = shape.GetFillColor(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Vector4((const Dali::Vector4 &)result); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetFillRule(char *pShape, - int rule) { - Dali::CanvasRenderer::Shape shape; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - shape.SetFillRule( - static_cast(rule)); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shape_GetFillRule(char *pShape) { - Dali::CanvasRenderer::Shape shape; - Dali::CanvasRenderer::Shape::FillRule result; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return 0; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - result = shape.GetFillRule(); - } - CALL_CATCH_EXCEPTION(0); - } - - return (int)result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeWidth(char *pShape, - float width) { - Dali::CanvasRenderer::Shape shape; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - shape.SetStrokeWidth(width); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Shape_GetStrokeWidth(char *pShape) { - Dali::CanvasRenderer::Shape shape; - float result; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return 0; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - result = shape.GetStrokeWidth(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeColor(char *pShape, - char *pColor) { - Dali::CanvasRenderer::Shape shape; - Dali::Vector4 color; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - if (!pColor) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, - "Dali::Vector4 const & type is null", - 0); - return; - } - color = *(Dali::Vector4 *)pColor; - { - try { - shape.SetStrokeColor(color); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Shape_GetStrokeColor(char *pShape) { - Dali::CanvasRenderer::Shape shape; - Dali::Vector4 result; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return 0; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - { - try { - result = shape.GetStrokeColor(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Vector4((const Dali::Vector4 &)result); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeDash( - char *pShape, float *pDashPattern, unsigned int patternLength) { - Dali::CanvasRenderer::Shape shape; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - if (!pDashPattern) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, - "Dash pattern is null", 0); - return; - } - - { - try { - Vector dashPattern; - for (unsigned int count = 0; count < patternLength; count++) { - dashPattern.PushBack(pDashPattern[count]); - } - shape.SetStrokeDash(dashPattern); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT unsigned int SWIGSTDCALL -CSharp_Dali_Shape_GetStrokeDashCount(char *pShape) { - Dali::CanvasRenderer::Shape shape; - unsigned int result; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return 0; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - - Dali::Vector dashPattern = shape.GetStrokeDash(); - result = dashPattern.Size(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT float SWIGSTDCALL -CSharp_Dali_Shape_GetStrokeDashIndexOf(char *pShape, unsigned int index) { - Dali::CanvasRenderer::Shape shape; - float result = 0.0f; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return 0; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - Dali::Vector dashPattern = shape.GetStrokeDash(); - if (index >= dashPattern.Size()) { - throw std::invalid_argument("invalid index"); - } - result = dashPattern[index]; - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeCap(char *pShape, - int cap) { - Dali::CanvasRenderer::Shape shape; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - shape.SetStrokeCap( - static_cast(cap)); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shape_GetStrokeCap(char *pShape) { - Dali::CanvasRenderer::Shape shape; - Dali::CanvasRenderer::Shape::StrokeCap result; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return 0; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - result = shape.GetStrokeCap(); - } - CALL_CATCH_EXCEPTION(0); - } - - return (int)result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeJoin(char *pShape, - int join) { - Dali::CanvasRenderer::Shape shape; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - shape.SetStrokeJoin( - static_cast(join)); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shape_GetStrokeJoin(char *pShape) { - Dali::CanvasRenderer::Shape shape; - Dali::CanvasRenderer::Shape::StrokeJoin result; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return 0; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - { - try { - result = shape.GetStrokeJoin(); - } - CALL_CATCH_EXCEPTION(0); - } - - return (int)result; -} - -SWIGEXPORT bool SWIGSTDCALL -CSharp_Dali_Shapep_SetFillGradient(char *pShape, char *pGradient) { - Dali::CanvasRenderer::Shape shape; - Dali::CanvasRenderer::Gradient gradient; - bool result = true; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return false; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - if (!pGradient) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0); - return false; - } - gradient = *(Dali::CanvasRenderer::Gradient *)pGradient; - { - try { - result = shape.SetFillGradient(gradient); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Shapep_GetFillGradient(char *pShape) { - Dali::CanvasRenderer::Shape shape; - Dali::CanvasRenderer::Gradient gradient; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return nullptr; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - gradient = shape.GetFillGradient(); - } - CALL_CATCH_EXCEPTION(nullptr); - } - - return new Dali::CanvasRenderer::Gradient( - (const Dali::CanvasRenderer::Gradient &)gradient); -} - -SWIGEXPORT bool SWIGSTDCALL -CSharp_Dali_Shapep_SetStrokeGradient(char *pShape, char *pGradient) { - Dali::CanvasRenderer::Shape shape; - Dali::CanvasRenderer::Gradient gradient; - bool result = true; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return false; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - if (!pGradient) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0); - return false; - } - gradient = *(Dali::CanvasRenderer::Gradient *)pGradient; - { - try { - shape.SetStrokeGradient(gradient); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void *SWIGSTDCALL -CSharp_Dali_Shapep_GetStrokeGradient(char *pShape) { - Dali::CanvasRenderer::Shape shape; - Dali::CanvasRenderer::Gradient gradient; - - if (!pShape) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Shape", 0); - return nullptr; - } - shape = *(Dali::CanvasRenderer::Shape *)pShape; - - { - try { - gradient = shape.GetStrokeGradient(); - } - CALL_CATCH_EXCEPTION(nullptr); - } - - return new Dali::CanvasRenderer::Gradient( - (const Dali::CanvasRenderer::Gradient &)gradient); -} - -// Dali::CanvasRenderer::DrawableGroup Wrapper - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_DrawableGroup_New() { - Dali::CanvasRenderer::DrawableGroup drawableGroup; - - { - try { - drawableGroup = Dali::CanvasRenderer::DrawableGroup::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::CanvasRenderer::DrawableGroup( - (const Dali::CanvasRenderer::DrawableGroup &)drawableGroup); -} - -SWIGEXPORT bool SWIGSTDCALL -CSharp_Dali_DrawableGroup_AddDrawable(char *pDrawableGroup, char *pDrawable) { - Dali::CanvasRenderer::DrawableGroup drawableGroup; - Dali::CanvasRenderer::Drawable drawable; - bool result = true; - - if (!pDrawableGroup) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::DrawableGroup", 0); - return false; - } - drawableGroup = *(Dali::CanvasRenderer::DrawableGroup *)pDrawableGroup; - - if (!pDrawable) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); - return false; - } - drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; - { - try { - drawableGroup.AddDrawable(drawable); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_DrawableGroup_RemoveDrawable( - char *pDrawableGroup, char *pDrawable) { - Dali::CanvasRenderer::DrawableGroup drawableGroup; - Dali::CanvasRenderer::Drawable drawable; - bool result = true; - - if (!pDrawableGroup) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::DrawableGroup", 0); - return false; - } - drawableGroup = *(Dali::CanvasRenderer::DrawableGroup *)pDrawableGroup; - - if (!pDrawable) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0); - return false; - } - drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable; - { - try { - drawableGroup.RemoveDrawable(drawable); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL -CSharp_Dali_DrawableGroup_RemoveAllDrawables(char *pDrawableGroup) { - Dali::CanvasRenderer::DrawableGroup drawableGroup; - bool result = false; - - if (!pDrawableGroup) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::DrawableGroup", 0); - return false; - } - drawableGroup = *(Dali::CanvasRenderer::DrawableGroup *)pDrawableGroup; - - { - try { - result = drawableGroup.RemoveAllDrawables(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -// Dali::CanvasRenderer::Gradient Wrapper - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gradient_SetColorStops( - char *pGradient, float *pStops, unsigned int stopsLength) { - Dali::CanvasRenderer::Gradient gradient; - - if (!pGradient) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0); - return; - } - gradient = *(Dali::CanvasRenderer::Gradient *)pGradient; - - if (!pStops) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, - "Stops is null", 0); - return; - } - - { - try { - Dali::CanvasRenderer::Gradient::ColorStops stops; - for (unsigned int count = 0; count < stopsLength; count++) { - Dali::CanvasRenderer::Gradient::ColorStop stop; - stop.offset = pStops[count * 5]; - stop.color = Vector4(pStops[(count * 5) + 1], pStops[(count * 5) + 2], - pStops[(count * 5) + 3], pStops[(count * 5) + 4]); - stops.PushBack(stop); - } - gradient.SetColorStops(stops); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT unsigned int SWIGSTDCALL -CSharp_Dali_Gradient_GetColorStopsCount(char *pGradient) { - Dali::CanvasRenderer::Gradient gradient; - unsigned int result = 0; - - if (!pGradient) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0); - return 0; - } - gradient = *(Dali::CanvasRenderer::Gradient *)pGradient; - - { - try { - Dali::CanvasRenderer::Gradient::ColorStops colorStops = - gradient.GetColorStops(); - result = colorStops.Size(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Gradient_GetColorStopsOffsetIndexOf( - char *pGradient, unsigned int index) { - Dali::CanvasRenderer::Gradient gradient; - float result = 0.0f; - - if (!pGradient) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0); - return 0.0f; - } - gradient = *(Dali::CanvasRenderer::Gradient *)pGradient; - - { - try { - Dali::CanvasRenderer::Gradient::ColorStops colorStops = - gradient.GetColorStops(); - if (index >= colorStops.Size()) { - throw std::invalid_argument("invalid index"); - } - result = colorStops[index].offset; - } - CALL_CATCH_EXCEPTION(0.0f); - } - - return result; -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Gradient_GetColorStopsColorIndexOf( - char *pGradient, unsigned int index) { - Dali::CanvasRenderer::Gradient gradient; - Dali::Vector4 result; - - if (!pGradient) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0); - return nullptr; - } - gradient = *(Dali::CanvasRenderer::Gradient *)pGradient; - - { - try { - Dali::CanvasRenderer::Gradient::ColorStops colorStops = - gradient.GetColorStops(); - if (index >= colorStops.Size()) { - throw std::invalid_argument("invalid index"); - } - result = colorStops[index].color; - } - CALL_CATCH_EXCEPTION(nullptr); - } - - return new Dali::Vector4((const Dali::Vector4 &)result); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gradient_SetSpread(char *pGradient, - int spread) { - Dali::CanvasRenderer::Gradient gradient; - - if (!pGradient) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0); - return; - } - gradient = *(Dali::CanvasRenderer::Gradient *)pGradient; - - { - try { - gradient.SetSpread( - static_cast(spread)); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gradient_GetSpread(char *pGradient) { - Dali::CanvasRenderer::Gradient gradient; - Dali::CanvasRenderer::Gradient::Spread result; - - if (!pGradient) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0); - return 0; - } - gradient = *(Dali::CanvasRenderer::Gradient *)pGradient; - - { - try { - result = gradient.GetSpread(); - } - CALL_CATCH_EXCEPTION(0); - } - - return (int)result; -} - -// Dali::CanvasRenderer::LinearGradient Wrapper - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_LinearGradient_New() { - Dali::CanvasRenderer::LinearGradient linearGradient; - - { - try { - linearGradient = Dali::CanvasRenderer::LinearGradient::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::CanvasRenderer::LinearGradient( - (const Dali::CanvasRenderer::LinearGradient &)linearGradient); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LinearGradient_SetBounds( - char *pLinearGradient, void *pFirstPoint, void *pSecondPoint) { - Dali::CanvasRenderer::LinearGradient linearGradient; - bool result = false; - - if (!pLinearGradient) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::LinearGradient", 0); - return false; - } - linearGradient = *(Dali::CanvasRenderer::LinearGradient *)pLinearGradient; - - if (!pFirstPoint) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::Vector2", 0); - return false; - } - - if (!pSecondPoint) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::Vector2", 0); - return false; - } - - { - try { - result = linearGradient.SetBounds(*(Dali::Vector2 *)pFirstPoint, - *(Dali::Vector2 *)pSecondPoint); - } - CALL_CATCH_EXCEPTION(false); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LinearGradient_GetBounds( - char *pLinearGradient, void *pFirstPoint, void *pSecondPoint) { - Dali::CanvasRenderer::LinearGradient linearGradient; - bool result = false; - - if (!pLinearGradient) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::LinearGradient", 0); - return false; - } - linearGradient = *(Dali::CanvasRenderer::LinearGradient *)pLinearGradient; - - if (!pFirstPoint) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::Vector2", 0); - return false; - } - - if (!pSecondPoint) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::Vector2", 0); - return false; - } - - { - try { - result = linearGradient.GetBounds(*(Dali::Vector2 *)pFirstPoint, - *(Dali::Vector2 *)pSecondPoint); - } - CALL_CATCH_EXCEPTION(false); - } - return result; -} - -// Dali::CanvasRenderer::RadialGradient Wrapper - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_RadialGradient_New() { - Dali::CanvasRenderer::RadialGradient radialGradient; - - { - try { - radialGradient = Dali::CanvasRenderer::RadialGradient::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::CanvasRenderer::RadialGradient( - (const Dali::CanvasRenderer::RadialGradient &)radialGradient); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RadialGradient_SetBounds( - char *pRadialGradient, void *pCenterPoint, float radius) { - Dali::CanvasRenderer::RadialGradient radialGradient; - bool result = false; - - if (!pRadialGradient) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::RadialGradient", 0); - return false; - } - radialGradient = *(Dali::CanvasRenderer::RadialGradient *)pRadialGradient; - - if (!pCenterPoint) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::Vector2", 0); - return false; - } - - { - try { - result = radialGradient.SetBounds(*(Dali::Vector2 *)pCenterPoint, radius); - } - CALL_CATCH_EXCEPTION(false); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RadialGradient_GetBounds( - char *pRadialGradient, void *pCenterPoint, void *radius) { - Dali::CanvasRenderer::RadialGradient radialGradient; - bool result = false; - - if (!pRadialGradient) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::CanvasRenderer::RadialGradient", 0); - return false; - } - radialGradient = *(Dali::CanvasRenderer::RadialGradient *)pRadialGradient; - - if (!pCenterPoint) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::Vector2", 0); - return false; - } - - { - try { - result = radialGradient.GetBounds(*(Dali::Vector2 *)pCenterPoint, - *(float *)radius); - } - CALL_CATCH_EXCEPTION(false); - } - return result; -} -#ifdef __cplusplus -} // end extern "C" -#endif diff --git a/dali-csharp-binder/src/capabilities-wrap.cpp b/dali-csharp-binder/src/capabilities-wrap.cpp deleted file mode 100644 index 1837aef3..00000000 --- a/dali-csharp-binder/src/capabilities-wrap.cpp +++ /dev/null @@ -1,42 +0,0 @@ -/* - * Copyright (c) 2020 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsBlendEquationSupported( int blendEquation ) { - bool jresult; - - { - try { - jresult = Dali::Capabilities::IsBlendEquationSupported( static_cast(blendEquation) ); - } - CALL_CATCH_EXCEPTION(0); - } - return jresult; -} - -#ifdef __cplusplus -} -#endif \ No newline at end of file diff --git a/dali-csharp-binder/src/capture-wrap.cpp b/dali-csharp-binder/src/capture-wrap.cpp deleted file mode 100755 index 2c9aba76..00000000 --- a/dali-csharp-binder/src/capture-wrap.cpp +++ /dev/null @@ -1,554 +0,0 @@ -/* - * Copyright (c) 2020 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -SWIGINTERN bool Dali_Capture_Signal_Empty(Dali::Capture::CaptureFinishedSignalType const* self) -{ - return self->Empty(); -} - -SWIGINTERN std::size_t Dali_Capture_Signal_GetConnectionCount(Dali::Capture::CaptureFinishedSignalType const* self) -{ - return self->GetConnectionCount(); -} - -SWIGINTERN void Dali_Capture_Signal_Connect(Dali::Capture::CaptureFinishedSignalType* self, void (*func)(Dali::Capture, Dali::Capture::FinishState)) -{ - self->Connect(func); -} - -SWIGINTERN void Dali_Capture_Signal_Disconnect(Dali::Capture::CaptureFinishedSignalType* self, void (*func)(Dali::Capture, Dali::Capture::FinishState)) -{ - self->Disconnect(func); -} - -SWIGINTERN void Dali_Capture_Signal_Emit(Dali::Capture::CaptureFinishedSignalType* self, Dali::Capture arg1, Dali::Capture::FinishState arg2) -{ - self->Emit(arg1, arg2); -} - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT Dali::BaseHandle* SWIGSTDCALL CSharp_Dali_Capture_Upcast(Dali::Capture* jarg1) -{ - return (Dali::BaseHandle*)jarg1; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Capture() -{ - void* jresult; - Dali::Capture* result = 0; - - { - try - { - result = (Dali::Capture*)new Dali::Capture(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Capture_New() -{ - void* jresult; - Dali::Capture result; - - { - try - { - result = Dali::Capture::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Capture((const Dali::Capture&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Capture_DownCast(void* jarg1) -{ - void* jresult; - Dali::BaseHandle arg1; - Dali::BaseHandle* argp1; - Dali::Capture 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::Capture::DownCast(arg1); - } - CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Capture((const Dali::Capture&)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Capture(void* jarg1) -{ - Dali::Capture* arg1 = (Dali::Capture*) 0; - - arg1 = (Dali::Capture*)jarg1; - { - try - { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Capture_New_With_CameraActor(void* jarg1) -{ - void* jresult; - Dali::CameraActor* arg1 = 0; - Dali::Capture result; - - arg1 = (Dali::CameraActor*)jarg1; - if (!arg1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor is null", 0); - return 0; - } - { - try - { - result = Dali::Capture::New(*arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Capture((const Dali::Capture&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Capture_Assign(void* jarg1, void* jarg2) -{ - void* jresult; - Dali::Capture* arg1 = (Dali::Capture*) 0; - Dali::Capture* arg2 = 0; - Dali::Capture* result = 0; - - arg1 = (Dali::Capture*)jarg1; - arg2 = (Dali::Capture*)jarg2; - - if (!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Capture const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Capture*) & (arg1)->operator =((Dali::Capture const&) * arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Capture_Start_1(void* nuiCapture, void* nuiSource, void* nuiSize, char* nuiPath, void* nuiClearColor) -{ - Dali::Capture* capture = (Dali::Capture*)0; - Dali::Actor* source = (Dali::Actor*)0; - Dali::Vector2* size = (Dali::Vector2*)0; - std::string* path; - std::string path_str(nuiPath); - Dali::Vector4* clearColor = (Dali::Vector4*)0; - - capture = (Dali::Capture*)nuiCapture; - source = (Dali::Actor*)nuiSource; - size = (Dali::Vector2*)nuiSize; - path = &path_str; - clearColor = (Dali::Vector4*)nuiClearColor; - - if (!capture || !source || !size || !path || !clearColor) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); - return; - } - - { - try - { - (capture)->Start(*source, (const Dali::Vector2&)*size, (const std::string&)*path, (const Dali::Vector4&) * clearColor); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Capture_Start_2(void* nuiCapture, void* nuiSource, void* nuiSize, char* nuiPath) -{ - Dali::Capture* capture = (Dali::Capture*)0; - Dali::Actor* source = (Dali::Actor*)0; - Dali::Vector2* size = (Dali::Vector2*)0; - std::string* path; - std::string path_str(nuiPath); - - capture = (Dali::Capture*)nuiCapture; - source = (Dali::Actor*)nuiSource; - size = (Dali::Vector2*)nuiSize; - path = &path_str; - - if (!capture || !source || !size || !path) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); - return; - } - - { - try - { - (capture)->Start(*source, (const Dali::Vector2&)*size, (const std::string&)*path); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Capture_Start_3(void* nuiCapture, void* nuiSource, void* nuiSize, char* nuiPath, void* nuiClearColor, uint32_t nuiQuality) -{ - Dali::Capture* capture = (Dali::Capture*)0; - Dali::Actor* source = (Dali::Actor*)0; - Dali::Vector2* size = (Dali::Vector2*)0; - std::string* path; - std::string path_str(nuiPath); - Dali::Vector4* clearColor = (Dali::Vector4*)0; - uint32_t quality; - - capture = (Dali::Capture*)nuiCapture; - source = (Dali::Actor*)nuiSource; - size = (Dali::Vector2*)nuiSize; - path = &path_str; - clearColor = (Dali::Vector4*)nuiClearColor; - quality = nuiQuality; - - if (!capture || !source || !size || !path || !clearColor) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); - return; - } - - { - try - { - (capture)->Start(*source, (const Dali::Vector2&)*size, (const std::string&)*path, (const Dali::Vector4&) * clearColor, quality); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Capture_Start_4( void* nuiCapture, void* nuiSource, void* nuiPosition, void* nuiSize, char* nuiPath, void* nuiClearColor ) -{ - Dali::Capture* capture = (Dali::Capture*)0; - Dali::Actor* source = (Dali::Actor*)0; - Dali::Vector2* position = (Dali::Vector2*)0; - Dali::Vector2* size = (Dali::Vector2*)0; - std::string* path; - std::string path_str(nuiPath); - Dali::Vector4* clearColor = (Dali::Vector4*)0; - - capture = (Dali::Capture*)nuiCapture; - source = (Dali::Actor*)nuiSource; - position = (Dali::Vector2*)nuiPosition; - size = (Dali::Vector2*)nuiSize; - path = &path_str; - clearColor = (Dali::Vector4*)nuiClearColor; - - if (!capture || !source || !size || !position || !path || !clearColor) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); - return; - } - - { - try - { - (capture)->Start(*source, (const Dali::Vector2&)*position, (const Dali::Vector2&)*size, (const std::string&)*path, (const Dali::Vector4&) * clearColor); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Capture_SetImageQuality( void* nuiCapture, uint32_t nuiQuality ) -{ - Dali::Capture* capture = (Dali::Capture*)0; - uint32_t quality = nuiQuality; - - capture = (Dali::Capture*)nuiCapture; - - if ( !capture ) - { - SWIG_CSharpSetPendingExceptionArgument( SWIG_CSharpArgumentNullException, "some argument is null", 0 ); - return; - } - - { - try - { - ( capture )->SetImageQuality( quality ); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Capture_Signal_Empty(void* jarg1) -{ - Dali::Capture::CaptureFinishedSignalType* arg1 = (Dali::Capture::CaptureFinishedSignalType*)jarg1; - bool result; - - { - try - { - result = Dali_Capture_Signal_Empty(arg1); - } - CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT std::size_t SWIGSTDCALL CSharp_Dali_Capture_Signal_GetConnectionCount(void* jarg1) -{ - Dali::Capture::CaptureFinishedSignalType* arg1 = (Dali::Capture::CaptureFinishedSignalType*)jarg1; - std::size_t result; - - { - try - { - result = Dali_Capture_Signal_GetConnectionCount((Dali::Capture::CaptureFinishedSignalType const*)arg1); - } - CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Capture_Signal_Connect(void* jarg1, void* jarg2) -{ - Dali::Capture::CaptureFinishedSignalType* arg1 = (Dali::Capture::CaptureFinishedSignalType*)jarg1; - void (*arg2)(Dali::Capture, Dali::Capture::FinishState) = (void (*)(Dali::Capture, Dali::Capture::FinishState))jarg2; - - { - try - { - Dali_Capture_Signal_Connect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Capture_Signal_Disconnect(void* jarg1, void* jarg2) -{ - Dali::Capture::CaptureFinishedSignalType* arg1 = (Dali::Capture::CaptureFinishedSignalType*)jarg1; - void (*arg2)(Dali::Capture, Dali::Capture::FinishState) = (void (*)(Dali::Capture, Dali::Capture::FinishState))jarg2; - - { - try - { - Dali_Capture_Signal_Disconnect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Capture_Signal_Emit(void* jarg1, void* jarg2, int jarg3) -{ - Dali::Capture::CaptureFinishedSignalType* arg1 = (Dali::Capture::CaptureFinishedSignalType*)jarg1; - Dali::Capture* arg2 = (Dali::Capture*)jarg2; - Dali::Capture::FinishState arg3; - - if (jarg3 == 0) - { - arg3 = Dali::Capture::FinishState::SUCCEEDED; - } - else { - arg3 = Dali::Capture::FinishState::FAILED; - } - - { - try - { - Dali_Capture_Signal_Emit(arg1, *arg2, arg3); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Capture_Signal() -{ - Dali::Capture::CaptureFinishedSignalType* result = 0; - - { - try - { - result = (Dali::Capture::CaptureFinishedSignalType*)new Dali::Capture::CaptureFinishedSignalType(); - } - CALL_CATCH_EXCEPTION(0); - } - return (void*)result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Capture_Signal(void* jarg1) -{ - Dali::Capture::CaptureFinishedSignalType* arg1 = (Dali::Capture::CaptureFinishedSignalType*)jarg1; - - { - try - { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Capture_Signal_Get(void* jarg1) -{ - Dali::Capture* arg1 = (Dali::Capture*)jarg1; - Dali::Capture::CaptureFinishedSignalType* result; - if (!arg1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); - return 0; - } - { - try - { - result = &(arg1->FinishedSignal()); - } - CALL_CATCH_EXCEPTION(0); - } - return (void*)result; -} - -struct NativeImageSourcePtrHandle -{ - Dali::NativeImageSourcePtr Ptr; -}; - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Capture_GetNativeImageSource(void* jarg1) -{ - Dali::Capture* arg1 = (Dali::Capture*)jarg1; - NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle(); - - if (!arg1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); - delete handle; - return 0; - } - { - try - { - handle->Ptr = arg1->GetNativeImageSource(); - } - catch (std::out_of_range &e) - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); - delete handle; - return 0; - } - catch (std::exception& e) - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); - delete handle; - return 0; - } - catch (Dali::DaliException e) - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); - delete handle; - return 0; - } - catch (...) - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); - delete handle; - return 0; - } - } - return (void*)handle; -} - -typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Capture_GenerateUrl(void* nuiCapture) -{ - Dali::Capture* capture = (Dali::Capture*)nuiCapture; - Dali::Toolkit::ImageUrl result; - void *jresult; - - if (!capture) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); - return 0; - } - { - try - { - result = Dali::Toolkit::Image::GenerateUrl(capture->GetNativeImageSource()); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result); - return jresult; -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Capture_GetCapturedBuffer(void *nuiCapture) -{ - Dali::Capture *capture = (Dali::Capture *)nuiCapture; - Dali::Devel::PixelBuffer pixelBuffer; - - if (!capture) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); - return 0; - } - { - try - { - pixelBuffer = Dali::DevelCapture::GetCapturedBuffer(*capture); - } - CALL_CATCH_EXCEPTION(0); - } - Dali::Devel::PixelBuffer *result = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)pixelBuffer); - return result; -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/common.cpp b/dali-csharp-binder/src/common.cpp deleted file mode 100644 index cf9bc001..00000000 --- a/dali-csharp-binder/src/common.cpp +++ /dev/null @@ -1,37 +0,0 @@ -/* - * Copyright (c) 2022 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. - * - */ - -// INTERNAL INCLUDES -#include "common.h" - -void SWIG_ExceptionMessageWithFileAndLine(const int& code, const char* what, const char* filename, const int& linenumber, const char* funcname) -{ - std::string message(what); - std::stringstream fileAndLine; - fileAndLine << " file: " << (filename) << " line: " << (linenumber) << " func: " << (funcname); - message += fileAndLine.str(); - SWIG_CSharpException((code), message.c_str()); -} - -void internal_try_catch(const std::function& func, const char* filename, const int& linenumber, const char* funcname) -{ - try - { - func(); - } - CALL_CATCH_EXCEPTION_WITH_CUSTOM_FILE_AND_LINE(, filename, linenumber, funcname); -} diff --git a/dali-csharp-binder/src/common.h b/dali-csharp-binder/src/common.h deleted file mode 100755 index 2051d47c..00000000 --- a/dali-csharp-binder/src/common.h +++ /dev/null @@ -1,368 +0,0 @@ -#ifndef CSHARP_COMMON_H -#define CSHARP_COMMON_H - -/* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - -#define SWIG_DIRECTORS - -#ifdef __cplusplus -/* SwigValueWrapper is described in swig.swg */ -template class SwigValueWrapper -{ - struct SwigMovePointer - { - T *ptr; - SwigMovePointer(T *p) : ptr(p) { } - ~SwigMovePointer() { delete ptr; } - SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } - } pointer; - SwigValueWrapper& operator=(const SwigValueWrapper& rhs); - SwigValueWrapper(const SwigValueWrapper& rhs); -public: - SwigValueWrapper() : pointer(0) { } - SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } - operator T&() const { return *pointer.ptr; } - T *operator&() { return pointer.ptr; } -}; - -template T SwigValueInit() -{ - return T(); -} -#endif - -#include - -#define SWIGSTDCALL - -/* attribute recognised by some compilers to avoid 'unused' warnings */ -#ifndef SWIGUNUSED -# if defined(__GNUC__) -# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) -# define SWIGUNUSED __attribute__ ((__unused__)) -# else -# define SWIGUNUSED -# endif -# elif defined(__ICC) -# define SWIGUNUSED __attribute__ ((__unused__)) -# else -# define SWIGUNUSED -# endif -#endif - -/* internal SWIG method */ -#ifndef SWIGINTERN -# define SWIGINTERN static SWIGUNUSED -#endif - -#ifndef SWIGEXPORT -# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# if defined(STATIC_LINKED) -# define SWIGEXPORT -# else -# define SWIGEXPORT __declspec(dllexport) -# endif -# else -# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) -# define SWIGEXPORT __attribute__ ((visibility("default"))) -# else -# define SWIGEXPORT -# endif -# endif -#endif - -#include -#include -#include -#include - -/* Errors in SWIG */ -constexpr static int SWIG_UnknownError = -1; -constexpr static int SWIG_IOError = -2; -constexpr static int SWIG_RuntimeError = -3; -constexpr static int SWIG_IndexError = -4; -constexpr static int SWIG_TypeError = -5; -constexpr static int SWIG_DivisionByZero = -6; -constexpr static int SWIG_OverflowError = -7; -constexpr static int SWIG_SyntaxError = -8; -constexpr static int SWIG_ValueError = -9; -constexpr static int SWIG_SystemError = -10; -constexpr static int SWIG_AttributeError = -11; -constexpr static int SWIG_MemoryError = -12; -constexpr static int SWIG_NullReferenceError = -13; - -/* Support for throwing C# exceptions from C/C++. There are two types: - * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */ -typedef enum -{ - SWIG_CSharpApplicationException, - SWIG_CSharpArithmeticException, - SWIG_CSharpDivideByZeroException, - SWIG_CSharpIndexOutOfRangeException, - SWIG_CSharpInvalidCastException, - SWIG_CSharpInvalidOperationException, - SWIG_CSharpIOException, - SWIG_CSharpNullReferenceException, - SWIG_CSharpOutOfMemoryException, - SWIG_CSharpOverflowException, - SWIG_CSharpSystemException -} SWIG_CSharpExceptionCodes; - -typedef enum -{ - SWIG_CSharpArgumentException, - SWIG_CSharpArgumentNullException, - SWIG_CSharpArgumentOutOfRangeException -} SWIG_CSharpExceptionArgumentCodes; - -typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *); -typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *); -typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); - -typedef struct -{ - SWIG_CSharpExceptionCodes code; - SWIG_CSharpExceptionCallback_t callback; -} SWIG_CSharpException_t; - -typedef struct -{ - SWIG_CSharpExceptionArgumentCodes code; - SWIG_CSharpExceptionArgumentCallback_t callback; -} SWIG_CSharpExceptionArgument_t; - -extern SWIG_CSharpException_t SWIG_csharp_exceptions[]; - -extern SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[]; - -extern void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg); - -extern void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name); - -extern void SWIG_CSharpException(int code, const char *msg); - - -#include - -#define SWIGSTDCALL - -#include -#include - -// Function to append SWIG_CSharpException message file/line/function. -extern void SWIG_ExceptionMessageWithFileAndLine(const int& code, const char* what, const char* filename, const int& linenumber, const char* funcname); - -#define SWIG_EXCEPTION_WITH_FILE_AND_LINE(code, what) \ -SWIG_ExceptionMessageWithFileAndLine((code), (what), __FILE__, __LINE__, __FUNCTION__) - -// Define Catch exception -#define CALL_CATCH_EXCEPTION(ret) \ - catch (std::out_of_range & e) \ - { \ - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_IndexError, const_cast(e.what())); \ - return ret; \ - } \ - catch (std::exception & e) \ - { \ - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_RuntimeError, const_cast(e.what())); \ - return ret; \ - } \ - catch (Dali::DaliException e) \ - { \ - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_SystemError, e.condition); \ - return ret; \ - } \ - catch (abi::__forced_unwind &) \ - { \ - DALI_LOG_ERROR("abi::__forced_unwind occured\n"); \ - return ret; \ - } \ - catch (...) \ - { \ - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_UnknownError, "unknown error"); \ - return ret; \ - } - -// Define Catch exception with inputed file and line infomations -#define CALL_CATCH_EXCEPTION_WITH_CUSTOM_FILE_AND_LINE(ret, filename, linenumber, funcname) \ - catch (std::out_of_range & e) \ - { \ - SWIG_ExceptionMessageWithFileAndLine(SWIG_IndexError, const_cast(e.what()), (filename), (linenumber), (funcname)); \ - return ret; \ - } \ - catch (std::exception & e) \ - { \ - SWIG_ExceptionMessageWithFileAndLine(SWIG_RuntimeError, const_cast(e.what()), (filename), (linenumber), (funcname)); \ - return ret; \ - } \ - catch (Dali::DaliException e) \ - { \ - SWIG_ExceptionMessageWithFileAndLine(SWIG_SystemError, e.condition, (filename), (linenumber), (funcname)); \ - return ret; \ - } \ - catch (abi::__forced_unwind &) \ - { \ - DALI_LOG_ERROR("abi::__forced_unwind occured\n"); \ - return ret; \ - } \ - catch (...) \ - { \ - SWIG_ExceptionMessageWithFileAndLine(SWIG_UnknownError, "unknown error", (filename), (linenumber), (funcname)); \ - return ret; \ - } - -// Define Catch exception if we need extra job before return -#define CALL_CATCH_EXCEPTION_WITH_FUNCTION(ret, func, ...) \ - catch (std::out_of_range & e) \ - { \ - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_IndexError, const_cast(e.what())); \ - (*(func))(__VA_ARGS__); \ - return ret; \ - } \ - catch (std::exception & e) \ - { \ - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_RuntimeError, const_cast(e.what())); \ - (*(func))(__VA_ARGS__); \ - return ret; \ - } \ - catch (Dali::DaliException e) \ - { \ - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_SystemError, e.condition); \ - (*(func))(__VA_ARGS__); \ - return ret; \ - } \ - catch (abi::__forced_unwind &) \ - { \ - DALI_LOG_ERROR("abi::__forced_unwind occured\n"); \ - (*(func))(__VA_ARGS__); \ - return ret; \ - } \ - catch (...) \ - { \ - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_UnknownError, "unknown error"); \ - (*(func))(__VA_ARGS__); \ - return ret; \ - } - -#define GUARD_ON_NULL_RET(arg_name) \ - if (!(arg_name)) { \ - std::stringstream output; \ - output << __FUNCTION__ << " is not allowed to take nullptr as " << #arg_name; \ - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, output.str().c_str(), #arg_name); \ - return; \ - } - -#define GUARD_ON_NULL_RET0(arg_name) \ - if (!(arg_name)) { \ - std::stringstream output; \ - output << __FUNCTION__ << " is not allowed to take nullptr as " << #arg_name; \ - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, output.str().c_str(), #arg_name); \ - return 0; \ - } - -// Define useful utils with lambda function -extern void internal_try_catch(const std::function& func, const char* filename, const int& linenumber, const char* funcname); - -// Define try_catch macro to get correct line and function_name -// NOTE: when lamda function use comma(,) at template, compiler think this is kind of argment divisor. -// This is compiler bug. So we need to cover the function by additional parentheses. -#define try_catch(func) internal_try_catch((func), __FILE__, __LINE__, __FUNCTION__) - - -// This macro generates 2 functions for signal: -// 1. CSharp_Someclass_SomeSignal_Connect(void* caller, void* handler) -// 2. CSharp_Someclass_SomeSignal_Disconnect(void* caller, void* handler) -// -// Arguments -// - CType: Type of Caller. For example, "Dali::Actor*" -// - HType: Type of Handler. For example, "void(*)(Dali::Actor*)" -// - Prefix: It can be a class name or namespace. This value determines the function name. -// - SignalName: The signal name to be called. For example, "TouchedSignal" -// -#ifndef GENERATE_SIGNAL -#define GENERATE_SIGNAL(CType, HType, Prefix, SignalName) \ - SWIGEXPORT void SWIGSTDCALL CSharp_##Prefix##_##SignalName##_Connect(void* caller, void* handler) \ - { \ - if(!caller) \ - { \ - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Caller (Type :" #CType ") is null", 0); \ - return; \ - } \ - try \ - { \ - ((CType)caller)->SignalName().Connect((HType)handler); \ - } \ - CALL_CATCH_EXCEPTION(); \ - } \ - SWIGEXPORT void SWIGSTDCALL CSharp_##Prefix##_##SignalName##_Disconnect(void* caller, void* handler) \ - { \ - if(!caller) \ - { \ - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Caller (Type :" #CType ") is null", 0); \ - return; \ - } \ - try \ - { \ - ((CType)caller)->SignalName().Disconnect((HType)handler); \ - } \ - CALL_CATCH_EXCEPTION(); \ - } -#endif - -// This macro generates 2 functions for signal declared in Devel class: -// 1. CSharp_Someclass_SomeSignal_Connect(void* caller, void* handler) -// 2. CSharp_Someclass_SomeSignal_Disconnect(void* caller, void* handler) -// -// Arguments -// - CType: Type of Caller. For example, "Dali::Actor*" -// - HType: Type of Handler. For example, "void(*)(Dali::Actor*)" -// - DevelType: Devel namespace. For example, "Dali::DevelActor" -// - Prefix: It can be a class name or namespace. This value determines the function name. -// - SignalName: The signal name to be called. For example, "TouchedSignal" -// -#ifndef GENERATE_DEVEL_SIGNAL -#define GENERATE_DEVEL_SIGNAL(CType, HType, DevelType, Prefix, SignalName) \ - SWIGEXPORT void SWIGSTDCALL CSharp_##Prefix##_##SignalName##_Connect(void* caller, void* handler) \ - { \ - if(!caller) \ - { \ - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Caller (Type :" #CType ") is null", 0); \ - return; \ - } \ - try \ - { \ - DevelType::SignalName(*((CType)caller)).Connect((HType)handler); \ - } \ - CALL_CATCH_EXCEPTION(); \ - } \ - SWIGEXPORT void SWIGSTDCALL CSharp_##Prefix##_##SignalName##_Disconnect(void* caller, void* handler) \ - { \ - if(!caller) \ - { \ - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Caller (Type :" #CType ") is null", 0); \ - return; \ - } \ - try \ - { \ - DevelType::SignalName(*((CType)caller)).Disconnect((HType)handler); \ - } \ - CALL_CATCH_EXCEPTION(); \ - } -#endif - -#endif // CSHARP_COMMON_H diff --git a/dali-csharp-binder/src/component-application-wrap.cpp b/dali-csharp-binder/src/component-application-wrap.cpp deleted file mode 100644 index 0727218d..00000000 --- a/dali-csharp-binder/src/component-application-wrap.cpp +++ /dev/null @@ -1,209 +0,0 @@ -/* - * Copyright (c) 2020 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -int argC = 1; -char **argV = NULL; - -typedef void* (*CreateNativeSignalType)(); -CreateNativeSignalType callback; - -Dali::Any CreateNativeSignalCallbackWrapper() -{ - return callback(); -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ComponentApplication(int jarg1, char * jarg2, char * jarg3) { - void * jresult ; - int *arg1 = (int *) 0 ; - char ***arg2 ; - std::string *arg3 = 0 ; - Dali::ComponentApplication result; - { - int index = 0; - int length = 0; - char *retPtr; - char *nextPtr; - argC = jarg1; - argV = new char*[jarg1 + 1]; - - retPtr = strtok_r( jarg2, " ", &nextPtr); - if( retPtr ) - { - length = strlen(retPtr); - } - argV[index] = new char[length + 1]; - if( retPtr ) - { - strncpy(argV[index], retPtr, length); - } - argV[index][length] = '\0'; - index++; - - while (index < jarg1) - { - length = 0; - retPtr = strtok_r(NULL, " ", &nextPtr); - if( retPtr ) - { - length = strlen(retPtr); - } - argV[index] = new char[length + 1]; - if( retPtr ) - { - strncpy(argV[index], retPtr, length); - } - argV[index][length] = '\0'; - index++; - } - - argV[jarg1] = NULL; - argC = jarg1; - - arg1 = &argC; - arg2 = &argV; - } - - if (!jarg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg3_str(jarg3); - arg3 = &arg3_str; - { - try { - result = Dali::ComponentApplication::New(arg1,arg2,(std::string const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::ComponentApplication((const Dali::ComponentApplication &)result); - - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ComponentApplication_SWIG1(void * jarg1) { - void * jresult ; - Dali::ComponentApplication *arg1 = 0 ; - Dali::ComponentApplication *result = 0 ; - - arg1 = (Dali::ComponentApplication *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ComponentApplication const & type is null", 0); - return 0; - } - { - try { - result = (Dali::ComponentApplication *)new Dali::ComponentApplication((Dali::ComponentApplication const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_assign_ComponentApplication(void * jarg1, void * jarg2) { - void * jresult ; - Dali::ComponentApplication *arg1 = (Dali::ComponentApplication *) 0 ; - Dali::ComponentApplication *arg2 = 0 ; - Dali::ComponentApplication *result = 0 ; - - arg1 = (Dali::ComponentApplication *)jarg1; - arg2 = (Dali::ComponentApplication *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ComponentApplication const & type is null", 0); - return 0; - } - { - try { - result = (Dali::ComponentApplication *) &(arg1)->operator =((Dali::ComponentApplication const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ComponentApplication(void * jarg1) { - Dali::ComponentApplication *arg1 = (Dali::ComponentApplication *) 0 ; - - arg1 = (Dali::ComponentApplication *)jarg1; - { - try { - delete arg1; - if( argV ) - { - // free string data - for( int i=0; i < argC+1; i++) - { - delete [] argV[i]; - } - delete [] argV; - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_ComponentApplication_CreateNativeSignal(void * jarg1) { - void* jresult ; - Dali::ComponentApplication *arg1 = (Dali::ComponentApplication *) 0 ; - Dali::ComponentApplication::CreateSignalType *result = 0 ; - - arg1 = (Dali::ComponentApplication *)jarg1; - { - try { - result = (Dali::ComponentApplication::CreateSignalType *) &(arg1)->CreateSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ComponentApplication_CreateNativeSignal_Connect(void * jarg1, void * jarg2) { - Dali::ComponentApplication *arg1 = (Dali::ComponentApplication *) 0 ; - arg1 = (Dali::ComponentApplication *)jarg1; - - callback = (CreateNativeSignalType) jarg2; - { - try { - (arg1)->CreateSignal().Connect(CreateNativeSignalCallbackWrapper); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ComponentApplication_CreateNativeSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::ComponentApplication *arg1 = (Dali::ComponentApplication *) 0 ; - arg1 = (Dali::ComponentApplication *)jarg1; - - { - try { - (arg1)->CreateSignal().Disconnect(CreateNativeSignalCallbackWrapper); - } CALL_CATCH_EXCEPTION(); - } -} -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/constraint-wrap.cpp b/dali-csharp-binder/src/constraint-wrap.cpp deleted file mode 100755 index 038d1d41..00000000 --- a/dali-csharp-binder/src/constraint-wrap.cpp +++ /dev/null @@ -1,342 +0,0 @@ -/* - * Copyright (c) 2021 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EqualConstraintWithParentFloat_New(void * nuiHandle, int nuiTargetIndex, int nuiParentIndex) -{ - Dali::Handle *handle = (Dali::Handle *) 0; - Dali::Property::Index targetIndex; - Dali::Property::Index parentIndex; - Dali::Constraint result; - void * jresult = 0; - - handle = (Dali::Handle *)nuiHandle; - if (!handle) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & const is null", 0); - return 0; - } - targetIndex = (Dali::Property::Index)nuiTargetIndex; - parentIndex = (Dali::Property::Index)nuiParentIndex; - - { - try - { - result = Dali::Constraint::New(*handle, targetIndex, Dali::EqualToConstraint()); - result.AddSource(Dali::ParentSource(parentIndex)); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Constraint((const Dali::Constraint &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RelativeConstraintWithParentFloat_New(void * nuiHandle, int nuiTargetIndex, int nuiParentIndex, float nuiRelativeRate) -{ - Dali::Handle *handle = (Dali::Handle *) 0; - Dali::Property::Index targetIndex; - Dali::Property::Index parentIndex; - float relativeRate; - Dali::Constraint result; - void * jresult = 0; - - handle = (Dali::Handle *)nuiHandle; - if (!handle) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & const is null", 0); - return 0; - } - targetIndex = (Dali::Property::Index)nuiTargetIndex; - parentIndex = (Dali::Property::Index)nuiParentIndex; - relativeRate = nuiRelativeRate; - - { - try - { - result = Dali::Constraint::New(*handle, targetIndex, Dali::RelativeToConstraintFloat(relativeRate)); - result.AddSource(Dali::ParentSource(parentIndex)); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Constraint((const Dali::Constraint &)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Constraint_Apply(void * nuiConstraint) -{ - Dali::Constraint *constraint = (Dali::Constraint *) 0; - - constraint = (Dali::Constraint *)nuiConstraint; - if (!constraint) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Constraint is null", 0); - return; - } - - { - try - { - (*constraint).Apply(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Constraint_Remove(void * nuiConstraint) -{ - Dali::Constraint *constraint = (Dali::Constraint *) 0; - - constraint = (Dali::Constraint *)nuiConstraint; - if (!constraint) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Constraint is null", 0); - return; - } - - { - try - { - (*constraint).Remove(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Constraint_REMOVE_ACTION_BAKE_get() -{ - int jresult = 0; - - { - try - { - jresult = (int)Dali::Constraint::BAKE; - } CALL_CATCH_EXCEPTION(0); - } - - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Constraint_REMOVE_ACTION_DISCARD_get() -{ - int jresult = 0; - - { - try - { - jresult = (int)Dali::Constraint::DISCARD; - } CALL_CATCH_EXCEPTION(0); - } - - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Constraint_DEFAULT_REMOVE_ACTION_get() -{ - int jresult = 0; - - { - try - { - jresult = (int)Dali::Constraint::DEFAULT_REMOVE_ACTION; - } CALL_CATCH_EXCEPTION(0); - } - - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Constraint_SetRemoveAction(void * nuiConstraint, int nuiRemoveAction) -{ - Dali::Constraint *constraint = (Dali::Constraint *) 0; - Dali::Constraint::RemoveAction removeAction = Dali::Constraint::DEFAULT_REMOVE_ACTION; - - constraint = (Dali::Constraint *)nuiConstraint; - if (!constraint) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Constraint is null", 0); - return; - } - removeAction = (Dali::Constraint::RemoveAction)nuiRemoveAction; - - { - try - { - (*constraint).SetRemoveAction(removeAction); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Constraint_GetRemoveAction(void * nuiConstraint) -{ - Dali::Constraint *constraint = (Dali::Constraint *) 0; - int jresult = 0; - - constraint = (Dali::Constraint *)nuiConstraint; - if (!constraint) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Constraint is null", 0); - return 0; - } - - { - try - { - jresult = (int)(*constraint).GetRemoveAction(); - } CALL_CATCH_EXCEPTION(0); - } - - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Constraint_SetTag(void * nuiConstraint, unsigned int nuiTag) -{ - Dali::Constraint *constraint = (Dali::Constraint *) 0; - uint32_t tag = 0; - - constraint = (Dali::Constraint *)nuiConstraint; - if (!constraint) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Constraint is null", 0); - return; - } - tag = nuiTag; - - { - try - { - (*constraint).SetTag(tag); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Constraint_GetTag(void * nuiConstraint) -{ - Dali::Constraint *constraint = (Dali::Constraint *) 0; - uint32_t jresult = 0; - - constraint = (Dali::Constraint *)nuiConstraint; - if (!constraint) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Constraint is null", 0); - return 0; - } - - { - try - { - jresult = (*constraint).GetTag(); - } CALL_CATCH_EXCEPTION(0); - } - - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Constraint_GetTargetObject(void * nuiConstraint) -{ - Dali::Constraint *constraint = (Dali::Constraint *) 0; - Dali::Handle result = Dali::Handle(); - void * jresult = 0; - - constraint = (Dali::Constraint *)nuiConstraint; - if (!constraint) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Constraint is null", 0); - return 0; - } - - { - try - { - result = (*constraint).GetTargetObject(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Handle((const Dali::Handle &)result); - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Constraint_GetTargetProperty(void * nuiConstraint) -{ - Dali::Constraint *constraint = (Dali::Constraint *) 0; - Dali::Property::Index result = Dali::Property::INVALID_INDEX; - int jresult = 0; - - constraint = (Dali::Constraint *)nuiConstraint; - if (!constraint) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Constraint is null", 0); - return 0; - } - - { - try - { - result = (*constraint).GetTargetProperty(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Constraint(void * nuiConstraint) -{ - Dali::Constraint *constraint = (Dali::Constraint *) 0; - Dali::Constraint *result; - void * jresult; - - constraint = (Dali::Constraint *)nuiConstraint; - if (!constraint) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Constraint is null", 0); - return 0; - } - - { - try - { - result = new Dali::Constraint(*constraint); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Constraint(void * nuiConstraint) -{ - Dali::Constraint *constraint = (Dali::Constraint *) 0; - - constraint = (Dali::Constraint *)nuiConstraint; - { - try - { - delete constraint; - } CALL_CATCH_EXCEPTION(); - } -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/control-devel-wrap.cpp b/dali-csharp-binder/src/control-devel-wrap.cpp deleted file mode 100644 index 53fcab31..00000000 --- a/dali-csharp-binder/src/control-devel-wrap.cpp +++ /dev/null @@ -1,593 +0,0 @@ -/* - * Copyright (c) 2022 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include - -// INTERNAL INCLUDES -#include "control-devel-wrap.h" -#include -#include -#include -#include -#include -#include -#include - -using namespace Dali; -using namespace Dali::Toolkit; -using namespace Dali::Toolkit::DevelControl; - -namespace -{ -typedef void (*SavedCallbackType)(int32_t, int32_t, uint32_t, float *val1, float *val2, float *val3); -SavedCallbackType gSavedRootCallback = nullptr; - -Dali::Property::Value RootCallback(int32_t id, VectorAnimationRenderer::VectorProperty property, uint32_t frameNumber) -{ - float val1 = 0.0f, val2 = 0.0f, val3 = 0.0f; - if(gSavedRootCallback != nullptr) - { - gSavedRootCallback(id, (int)property, frameNumber, &val1, &val2, &val3); - } - - switch(property) - { - case VectorAnimationRenderer::VectorProperty::FILL_COLOR : - case VectorAnimationRenderer::VectorProperty::STROKE_COLOR : - return Dali::Vector3(val1, val2, val3); - break; - - case VectorAnimationRenderer::VectorProperty::TRANSFORM_ANCHOR : - case VectorAnimationRenderer::VectorProperty::TRANSFORM_POSITION : - case VectorAnimationRenderer::VectorProperty::TRANSFORM_SCALE : - return Dali::Vector2(val1, val2); - break; - - case VectorAnimationRenderer::VectorProperty::FILL_OPACITY : - case VectorAnimationRenderer::VectorProperty::STROKE_OPACITY : - case VectorAnimationRenderer::VectorProperty::STROKE_WIDTH : - case VectorAnimationRenderer::VectorProperty::TRANSFORM_ROTATION : - case VectorAnimationRenderer::VectorProperty::TRANSFORM_OPACITY : - return val1; - break; - - default: - return 0; - break; - } -} -} //unnamed namespace - -#ifdef __cplusplus -extern "C" { -#endif - -// property -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_DISPATCH_KEY_EVENTS_get() -{ - return (int)Dali::Toolkit::DevelControl::Property::DISPATCH_KEY_EVENTS; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityActivateSignal(void* arg1) -{ - Dali::Toolkit::DevelControl::AccessibilityActivateSignalType* result = nullptr; - GUARD_ON_NULL_RET0(arg1); - try_catch(([&]() { - Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1; - result = &(AccessibilityActivateSignal(*control)); - })); - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityReadingSkippedSignal(void* arg1) -{ - Dali::Toolkit::DevelControl::AccessibilityReadingSkippedSignalType* result = nullptr; - GUARD_ON_NULL_RET0(arg1); - try_catch(([&]() { - Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1; - result = &(AccessibilityReadingSkippedSignal(*control)); - })); - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityReadingPausedSignal(void* arg1) -{ - Dali::Toolkit::DevelControl::AccessibilityReadingPausedSignalType* result = nullptr; - GUARD_ON_NULL_RET0(arg1); - try_catch(([&]() { - Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1; - result = &(AccessibilityReadingPausedSignal(*control)); - })); - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityReadingResumedSignal(void* arg1) -{ - Dali::Toolkit::DevelControl::AccessibilityReadingResumedSignalType* result = nullptr; - GUARD_ON_NULL_RET0(arg1); - try_catch(([&]() { - Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1; - result = &(AccessibilityReadingResumedSignal(*control)); - })); - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityReadingCancelledSignal(void* arg1) -{ - Dali::Toolkit::DevelControl::AccessibilityReadingCancelledSignalType* result = nullptr; - GUARD_ON_NULL_RET0(arg1); - try_catch(([&]() { - Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1; - result = &(AccessibilityReadingCancelledSignal(*control)); - })); - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityReadingStoppedSignal(void* arg1) -{ - Dali::Toolkit::DevelControl::AccessibilityReadingStoppedSignalType* result = nullptr; - GUARD_ON_NULL_RET0(arg1); - try_catch(([&]() { - Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1; - result = &(AccessibilityReadingStoppedSignal(*control)); - })); - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityGetNameSignal(void* arg1) -{ - Dali::Toolkit::DevelControl::AccessibilityGetNameSignalType* result = nullptr; - GUARD_ON_NULL_RET0(arg1); - try_catch(([&]() { - Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1; - result = &(AccessibilityGetNameSignal(*control)); - })); - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityGetDescriptionSignal(void* arg1) -{ - Dali::Toolkit::DevelControl::AccessibilityGetDescriptionSignalType* result = nullptr; - GUARD_ON_NULL_RET0(arg1); - try_catch(([&]() { - Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1; - result = &(AccessibilityGetDescriptionSignal(*control)); - })); - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityDoGestureSignal(void* arg1) -{ - Dali::Toolkit::DevelControl::AccessibilityDoGestureSignalType* result = nullptr; - GUARD_ON_NULL_RET0(arg1); - try_catch(([&]() { - Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1; - result = &(AccessibilityDoGestureSignal(*control)); - })); - return (void*)result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AppendAccessibilityRelation(void* arg1, void* arg2, int arg3) -{ - GUARD_ON_NULL_RET(arg1); - GUARD_ON_NULL_RET(arg2); - try_catch(([&]() { - auto* control = (Dali::Toolkit::Control*)arg1; - auto* destination = (Dali::Actor*)arg2; - auto relation = (Dali::Accessibility::RelationType)arg3; - AppendAccessibilityRelation(*control, *destination, relation); - })); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_RemoveAccessibilityRelation(void* arg1, void* arg2, int arg3) -{ - GUARD_ON_NULL_RET(arg1); - GUARD_ON_NULL_RET(arg2); - try_catch(([&]() { - auto* control = (Dali::Toolkit::Control*)arg1; - auto* destination = (Dali::Actor*)arg2; - auto relation = (Dali::Accessibility::RelationType)arg3; - RemoveAccessibilityRelation(*control, *destination, relation); - })); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_GetAccessibilityRelations(void* arg1_control, - void (*arg2_callback)(int, void*, void*), - void* arg3_userData) -{ - using namespace Dali::Accessibility; - - GUARD_ON_NULL_RET(arg1_control); - GUARD_ON_NULL_RET(arg2_callback); - - try_catch(([&]() { - auto* control = static_cast(arg1_control); - std::vector relations = GetAccessibilityRelations(*control); - - for(Relation& relation : relations) - { - for(Accessible* target : relation.mTargets) - { - // NUI is unaware of Accessible objects, so we only report those - // convertible to Control. Note that it is currently impossible to make - // a relation with anything other than Control (View) using NUI API, so - // there should not be any loss of information for typical NUI - // applications. - auto targetControl = Dali::Toolkit::Control::DownCast(target->GetInternalActor()); - - if(targetControl) - { - arg2_callback(static_cast(relation.mRelationType), - static_cast(new Dali::Actor(targetControl)), - arg3_userData); - } - } - } - })); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_ClearAccessibilityRelations(void* arg1) -{ - GUARD_ON_NULL_RET(arg1); - try_catch(([&]() { - auto* control = (Dali::Toolkit::Control*)arg1; - ClearAccessibilityRelations(*control); - })); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_SetAccessibilityReadingInfoType2(void* arg1, int arg2) -{ - using namespace Dali::Accessibility; - static_assert(static_cast(ReadingInfoType::NAME) == 0 && - static_cast(ReadingInfoType::ROLE) == 1 && - static_cast(ReadingInfoType::DESCRIPTION) == 2 && - static_cast(ReadingInfoType::STATE) == 3, - "C++ and C# bindings does not match"); - - GUARD_ON_NULL_RET(arg1); - try_catch(([&]() { - auto* control = (Dali::Toolkit::Control*)arg1; - SetAccessibilityReadingInfoType(*control, ReadingInfoTypes{static_cast(arg2)}); - })); -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_GetAccessibilityReadingInfoType2(void* arg1) -{ - int result = 0; - GUARD_ON_NULL_RET0(arg1); - try_catch(([&]() { - auto* control = (Dali::Toolkit::Control*)arg1; - auto readingInfo = GetAccessibilityReadingInfoType(*control); - result = readingInfo.GetRawData()[0]; - })); - return result; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_ClearAccessibilityHighlight(void* arg1) -{ - bool result = false; - GUARD_ON_NULL_RET0(arg1); - try_catch(([&]() { - auto* control = (Dali::Toolkit::Control*)arg1; - result = ClearAccessibilityHighlight(*control); - })); - return result; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_GrabAccessibilityHighlight(void* arg1) -{ - bool result = false; - GUARD_ON_NULL_RET0(arg1); - try_catch(([&]() { - auto* control = (Dali::Toolkit::Control*)arg1; - result = GrabAccessibilityHighlight(*control); - })); - return result; -} - -SWIGEXPORT uint64_t SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_GetAccessibilityStates(void* arg1) -{ - uint64_t result = 0; - GUARD_ON_NULL_RET0(arg1); - try_catch(([&]() { - auto* control = (Dali::Toolkit::Control*)arg1; - auto states = GetAccessibilityStates(*control); - result = states.GetRawData64(); - })); - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_NotifyAccessibilityStateChange(void* arg1, uint64_t arg2, int arg3) -{ - GUARD_ON_NULL_RET(arg1); - try_catch(([&]() { - Dali::Accessibility::States states(arg2); - auto* control = (Dali::Toolkit::Control*)arg1; - NotifyAccessibilityStateChange(*control, states, static_cast(arg3)); - })); -} - -/*********************************************** - **************** Accessibility **************** - ***********************************************/ - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_EmitAccessibilityEvent(void* arg1, int arg2_event) -{ - GUARD_ON_NULL_RET(arg1); - try_catch(([&]() { - Dali::Actor* control = (Dali::Actor*)arg1; - auto accessible = Dali::Accessibility::Accessible::Get(*control); - if(accessible) - { - accessible->Emit((Dali::Accessibility::ObjectPropertyChangeEvent)arg2_event); - } - else - { - SWIG_CSharpException(SWIG_RuntimeError, "Actor does not have accessible object."); - } - })); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_EmitAccessibilityStateChangedEvent(void* arg1, int arg2_state, int arg3) -{ - GUARD_ON_NULL_RET(arg1); - try_catch(([&]() { - auto state = static_cast(arg2_state); - - Dali::Actor* control = (Dali::Actor*)arg1; - auto accessible = Dali::Accessibility::Accessible::Get(*control); - if(accessible) - { - accessible->EmitStateChanged(state, arg3); - } - else - { - SWIG_CSharpException(SWIG_RuntimeError, "Actor does not have accessible object."); - } - })); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_EmitTextInsertedEvent( - void* arg1, int arg2_position, int arg3_length, char* arg4_content) -{ - GUARD_ON_NULL_RET(arg1); - try_catch(([&]() { - Dali::Actor* control = (Dali::Actor*)arg1; - auto accessible = Dali::Accessibility::Accessible::Get(*control); - std::string content(arg4_content ? arg4_content : ""); - if(accessible) - { - accessible->EmitTextInserted(arg2_position, arg3_length, content); - } - else - { - SWIG_CSharpException(SWIG_RuntimeError, "Actor does not have accessible object."); - } - })); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_EmitTextDeletedEvent( - void* arg1, int arg2_position, int arg3_length, char* arg4_content) -{ - GUARD_ON_NULL_RET(arg1); - try_catch(([&]() { - Dali::Actor* control = (Dali::Actor*)arg1; - auto accessible = Dali::Accessibility::Accessible::Get(*control); - std::string content(arg4_content ? arg4_content : ""); - if(accessible) - { - accessible->EmitTextDeleted(arg2_position, arg3_length, content); - } - else - { - SWIG_CSharpException(SWIG_RuntimeError, "Actor does not have accessible object."); - } - })); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_EmitTextCursorMovedEvent( - void* arg1, int arg2_position) -{ - GUARD_ON_NULL_RET(arg1); - try_catch(([&]() { - Dali::Actor* control = (Dali::Actor*)arg1; - auto accessible = Dali::Accessibility::Accessible::Get(*control); - if(accessible) - { - accessible->EmitTextCursorMoved(arg2_position); - } - else - { - SWIG_CSharpException(SWIG_RuntimeError, "Actor does not have accessible object."); - } - })); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_EmitScrollStartedEvent(void* arg1_actor) -{ - GUARD_ON_NULL_RET(arg1_actor); - try_catch(([&]() { - Dali::Actor* control = (Dali::Actor*)arg1_actor; - auto accessible = Dali::Accessibility::Accessible::Get(*control); - if(accessible) - { - accessible->EmitScrollStarted(); - } - else - { - SWIG_CSharpException(SWIG_RuntimeError, "Actor does not have accessible object."); - } - })); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_EmitScrollFinishedEvent(void* arg1_actor) -{ - GUARD_ON_NULL_RET(arg1_actor); - try_catch(([&]() { - Dali::Actor* control = (Dali::Actor*)arg1_actor; - auto accessible = Dali::Accessibility::Accessible::Get(*control); - if(accessible) - { - accessible->EmitScrollFinished(); - } - else - { - SWIG_CSharpException(SWIG_RuntimeError, "Actor does not have accessible object."); - } - })); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Accessibility_IsSuppressedEvent(void* arg1, int32_t atspiEvent) -{ - bool result = false; - GUARD_ON_NULL_RET0(arg1); - try_catch(([&]() { - Dali::Actor* control = (Dali::Actor*)arg1; - auto accessible = Dali::Accessibility::Accessible::Get(*control); - if(accessible) - { - result = accessible->GetSuppressedEvents()[static_cast(atspiEvent)]; - } - })); - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_SetSuppressedEvent(void* arg1, int32_t atspiEvent, bool isSuppressed) -{ - GUARD_ON_NULL_RET(arg1); - try_catch(([&]() { - Dali::Actor* control = (Dali::Actor*)arg1; - auto accessible = Dali::Accessibility::Accessible::Get(*control); - if(accessible) - { - accessible->GetSuppressedEvents()[static_cast(atspiEvent)] = isSuppressed; - } - })); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Accessibility_new_Range( - int arg1_start, int arg2_end, char* arg3_content) -{ - Dali::Accessibility::Range* result = nullptr; - try_catch(([&]() { - result = new Dali::Accessibility::Range(arg1_start, arg2_end, arg3_content); - })); - return (void*)result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_delete_Range(void* arg1_range) -{ - try_catch(([&]() { - delete static_cast(arg1_range); - })); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_Bridge_RegisterDefaultLabel(void* arg1_actor) -{ - GUARD_ON_NULL_RET(arg1_actor); - try_catch(([&]() { - Dali::Actor* actor = (Dali::Actor*)arg1_actor; - auto accessible = Dali::Accessibility::Accessible::Get(*actor); - auto bridge = Dali::Accessibility::Bridge::GetCurrentBridge(); - - if(!accessible) - { - SWIG_CSharpException(SWIG_RuntimeError, "No accessible object bind with actor."); - return; - } - - bridge->RegisterDefaultLabel(accessible); - })); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_Bridge_UnregisterDefaultLabel(void* arg1_actor) -{ - GUARD_ON_NULL_RET(arg1_actor); - try_catch(([&]() { - Dali::Actor* actor = (Dali::Actor*)arg1_actor; - auto accessible = Dali::Accessibility::Accessible::Get(*actor); - auto bridge = Dali::Accessibility::Bridge::GetCurrentBridge(); - - if(!accessible) - { - SWIG_CSharpException(SWIG_RuntimeError, "No accessible object bind with actor."); - return; - } - - bridge->UnregisterDefaultLabel(accessible); - })); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Accessibility_Accessible_GetCurrentlyHighlightedActor() -{ - Dali::Actor* result = NULL; - try_catch(([&]() { - Dali::Actor actor = Dali::Accessibility::Accessible::GetCurrentlyHighlightedActor(); - if(actor) - { - result = new Dali::Actor(actor); - } - })); - return result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Accessibility_Accessible_GetHighlightActor() -{ - Dali::Actor* result = NULL; - try_catch(([&]() { - Dali::Actor actor = Dali::Accessibility::Accessible::GetHighlightActor(); - if(actor) - { - result = new Dali::Actor(actor); - } - })); - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_Accessible_SetHighlightActor(void* arg1_actor) -{ - // Passing nullptr as actor is used to remove custom highlight, - // what leads to the restoration of default highlight starting - // from next call to GrabHighlight() - try_catch(([&]() { - Dali::Actor actor = arg1_actor ? *((Dali::Actor*)arg1_actor) : Dali::Actor(); - Dali::Accessibility::Accessible::SetHighlightActor(actor); - })); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoActionExtension(void * control, int visualIndex, int actionId, int callbackId, char* keyPath, int property, void * callback) -{ - DevelAnimatedVectorImageVisual::DynamicPropertyInfo info; - info.id = callbackId; - std::string path(keyPath); - info.keyPath = path; - info.property = property; - gSavedRootCallback = (void (*)(int32_t, int32_t, uint32_t, float *val1, float *val2, float *val3))callback; - info.callback = Dali::MakeCallback((Dali::Property::Value (*)(int32_t, int32_t, uint32_t))RootCallback); - - try - { - DevelControl::DoActionExtension(*((Dali::Toolkit::Control *)control), (Dali::Property::Index)visualIndex, (Dali::Property::Index)actionId, Dali::Any(info)); - } CALL_CATCH_EXCEPTION(); -} - -#ifdef __cplusplus -} // extern "C" -#endif diff --git a/dali-csharp-binder/src/control-devel-wrap.h b/dali-csharp-binder/src/control-devel-wrap.h deleted file mode 100644 index 3154db5f..00000000 --- a/dali-csharp-binder/src/control-devel-wrap.h +++ /dev/null @@ -1,32 +0,0 @@ -#ifndef CONTROL_DEVEL_WRAP_H -#define CONTROL_DEVEL_WRAP_H - -/* - * Copyright (c) 2021 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -/* Callback for returning strings to C# without leaking memory */ -typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -#endif // CONTROL_DEVEL_WRAP_H - diff --git a/dali-csharp-binder/src/dali-wrap.cpp b/dali-csharp-binder/src/dali-wrap.cpp deleted file mode 100644 index 32f15e20..00000000 --- a/dali-csharp-binder/src/dali-wrap.cpp +++ /dev/null @@ -1,53610 +0,0 @@ -/* ---------------------------------------------------------------------------- - * This file was automatically generated by SWIG (http://www.swig.org). - * Version 3.0.9 - * - * This file is not intended to be easily readable and contains a number of - * coding conventions designed to improve portability and efficiency. Do not make - * changes to this file unless you know what you are doing--modify the SWIG - * interface file instead. - * ----------------------------------------------------------------------------- */ - -#ifndef SWIGCSHARP -#define SWIGCSHARP -#endif - -#define SWIG_DIRECTORS - - -/* ----------------------------------------------------------------------------- - * This section contains generic SWIG labels for method/variable - * declarations/attributes, and other compiler dependent labels. - * ----------------------------------------------------------------------------- */ - -/* template workaround for compilers that cannot correctly implement the C++ standard */ -#ifndef SWIGTEMPLATEDISAMBIGUATOR -# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) -# define SWIGTEMPLATEDISAMBIGUATOR template -# elif defined(__HP_aCC) -/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ -/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ -# define SWIGTEMPLATEDISAMBIGUATOR template -# else -# define SWIGTEMPLATEDISAMBIGUATOR -# endif -#endif - -/* inline attribute */ -#ifndef SWIGINLINE -# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) -# define SWIGINLINE inline -# else -# define SWIGINLINE -# endif -#endif - -/* attribute recognised by some compilers to avoid 'unused' warnings */ -#ifndef SWIGUNUSED -# if defined(__GNUC__) -# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) -# define SWIGUNUSED __attribute__ ((__unused__)) -# else -# define SWIGUNUSED -# endif -# elif defined(__ICC) -# define SWIGUNUSED __attribute__ ((__unused__)) -# else -# define SWIGUNUSED -# endif -#endif - -#ifndef SWIG_MSC_UNSUPPRESS_4505 -# if defined(_MSC_VER) -# pragma warning(disable : 4505) /* unreferenced local function has been removed */ -# endif -#endif - -#ifndef SWIGUNUSEDPARM -# ifdef __cplusplus -# define SWIGUNUSEDPARM(p) -# else -# define SWIGUNUSEDPARM(p) p SWIGUNUSED -# endif -#endif - -/* internal SWIG method */ -#ifndef SWIGINTERN -# define SWIGINTERN static SWIGUNUSED -#endif - -/* internal inline SWIG method */ -#ifndef SWIGINTERNINLINE -# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE -#endif - -/* exporting methods */ -#if defined(__GNUC__) -# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) -# ifndef GCC_HASCLASSVISIBILITY -# define GCC_HASCLASSVISIBILITY -# endif -# endif -#endif - -#ifndef SWIGEXPORT -# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# if defined(STATIC_LINKED) -# define SWIGEXPORT -# else -# define SWIGEXPORT __declspec(dllexport) -# endif -# else -# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) -# define SWIGEXPORT __attribute__ ((visibility("default"))) -# else -# define SWIGEXPORT -# endif -# endif -#endif - -/* calling conventions for Windows */ -#ifndef SWIGSTDCALL -# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# define SWIGSTDCALL __stdcall -# else -# define SWIGSTDCALL -# endif -#endif - -/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ -#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) -# define _CRT_SECURE_NO_DEPRECATE -#endif - -/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ -#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) -# define _SCL_SECURE_NO_DEPRECATE -#endif - -/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ -#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) -# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 -#endif - -/* Intel's compiler complains if a variable which was never initialised is - * cast to void, which is a common idiom which we use to indicate that we - * are aware a variable isn't used. So we just silence that warning. - * See: https://github.com/swig/swig/issues/192 for more discussion. - */ -#ifdef __INTEL_COMPILER -# pragma warning disable 592 -#endif - -// EXTERNAL INCLUDES -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - - -// INTERNAL INCLUDES -#include "common.h" -#include "slim-custom-view-impl.h" - -#include - -#include -#include - -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include - -#include -#include - -#include -#include -#include -#include -#include - -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include - -#include - -#include - -#include - -#include -#include -#include - -#include -#include - - -SWIG_CSharpException_t SWIG_csharp_exceptions[] = { - { SWIG_CSharpApplicationException, NULL }, - { SWIG_CSharpArithmeticException, NULL }, - { SWIG_CSharpDivideByZeroException, NULL }, - { SWIG_CSharpIndexOutOfRangeException, NULL }, - { SWIG_CSharpInvalidCastException, NULL }, - { SWIG_CSharpInvalidOperationException, NULL }, - { SWIG_CSharpIOException, NULL }, - { SWIG_CSharpNullReferenceException, NULL }, - { SWIG_CSharpOutOfMemoryException, NULL }, - { SWIG_CSharpOverflowException, NULL }, - { SWIG_CSharpSystemException, NULL } -}; - -SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = { - { SWIG_CSharpArgumentException, NULL }, - { SWIG_CSharpArgumentNullException, NULL }, - { SWIG_CSharpArgumentOutOfRangeException, NULL } -}; - -void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) { - SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback; - if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) { - callback = SWIG_csharp_exceptions[code].callback; - } - callback(msg); -} - -void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) { - SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback; - if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) { - callback = SWIG_csharp_exceptions_argument[code].callback; - } - callback(msg, param_name); -} - - -#ifdef __cplusplus -extern "C" -#endif -SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic( - SWIG_CSharpExceptionCallback_t applicationCallback, - SWIG_CSharpExceptionCallback_t arithmeticCallback, - SWIG_CSharpExceptionCallback_t divideByZeroCallback, - SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback, - SWIG_CSharpExceptionCallback_t invalidCastCallback, - SWIG_CSharpExceptionCallback_t invalidOperationCallback, - SWIG_CSharpExceptionCallback_t ioCallback, - SWIG_CSharpExceptionCallback_t nullReferenceCallback, - SWIG_CSharpExceptionCallback_t outOfMemoryCallback, - SWIG_CSharpExceptionCallback_t overflowCallback, - SWIG_CSharpExceptionCallback_t systemCallback) { - SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback; - SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback; - SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback; - SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback; - SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback; - SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback; - SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback; - SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback; - SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback; - SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback; - SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback; -} - -#ifdef __cplusplus -extern "C" -#endif -SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic( - SWIG_CSharpExceptionArgumentCallback_t argumentCallback, - SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback, - SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) { - SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback; - SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback; - SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback; -} - - -/* Callback for returning strings to C# without leaking memory */ -typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); -SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL; - -// keep argWidgetCs and argWidgetV so they're always available to DALi -int argWidgetC = 1; -char **argWidgetV = NULL; - -#ifdef __cplusplus -extern "C" -#endif -SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) { - SWIG_csharp_string_callback = callback; -} - - -/* Contract support */ -#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else - - -/* ----------------------------------------------------------------------------- - * director_common.swg - * - * This file contains support for director classes which is common between - * languages. - * ----------------------------------------------------------------------------- */ - -/* - Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the - 'Swig' namespace. This could be useful for multi-modules projects. -*/ -#ifdef SWIG_DIRECTOR_STATIC -/* Force anonymous (static) namespace */ -#define Swig -#endif -/* ----------------------------------------------------------------------------- - * director.swg - * - * This file contains support for director classes so that C# proxy - * methods can be called from C++. - * ----------------------------------------------------------------------------- */ - -#if defined(DEBUG_DIRECTOR_OWNED) -#include -#endif - -namespace Swig { - /* Director base class - not currently used in C# directors */ - class Director { - }; - - /* Base class for director exceptions */ - class DirectorException : public std::exception { - protected: - std::string swig_msg; - - public: - DirectorException(const char *msg) : swig_msg(msg) { - } - - DirectorException(const std::string &msg) : swig_msg(msg) { - } - - virtual ~DirectorException() throw() { - } - - const char *what() const throw() { - return swig_msg.c_str(); - } - }; - - /* Pure virtual method exception */ - class DirectorPureVirtualException : public DirectorException { - public: - DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) { - } - }; -} - - -void SWIG_CSharpException(int code, const char *msg) { - if (code == SWIG_ValueError) { - SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException; - SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0); - } else { - SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException; - switch(code) { - case SWIG_MemoryError: - exception_code = SWIG_CSharpOutOfMemoryException; - break; - case SWIG_IndexError: - exception_code = SWIG_CSharpIndexOutOfRangeException; - break; - case SWIG_DivisionByZero: - exception_code = SWIG_CSharpDivideByZeroException; - break; - case SWIG_IOError: - exception_code = SWIG_CSharpIOException; - break; - case SWIG_OverflowError: - exception_code = SWIG_CSharpOverflowException; - break; - case SWIG_RuntimeError: - case SWIG_TypeError: - case SWIG_SyntaxError: - case SWIG_SystemError: - case SWIG_UnknownError: - default: - exception_code = SWIG_CSharpApplicationException; - break; - } - SWIG_CSharpSetPendingException(exception_code, msg); - } -} - - -#define SWIGSTDCALL - -// add here SWIG version check - -#if defined(_MSC_VER) // Microsoft Visual C++ 6.0 -// disable Swig-dependent warnings - -// 'identifier1' has C-linkage specified, -// but returns UDT 'identifier2' which is incompatible with C -#pragma warning(disable: 4190) - -// 'int' : forcing value to bool 'true' or 'false' (performance warning) -#pragma warning(disable: 4800) - -// debug info too long etc etc -#pragma warning(disable: 4786) -#endif - -typedef float floatp; - -SWIGINTERN floatp *new_floatp(){ - return new float(); -} -SWIGINTERN void delete_floatp(floatp *self){ - if (self) delete self; -} -SWIGINTERN void floatp_assign(floatp *self,float value){ - *self = value; -} -SWIGINTERN float floatp_value(floatp *self){ - return *self; -} -SWIGINTERN float *floatp_cast(floatp *self){ - return self; -} -SWIGINTERN floatp *floatp_frompointer(float *t){ - return (floatp *) t; -} - -typedef int intp; - -SWIGINTERN intp *new_intp(){ - return new int(); -} -SWIGINTERN void delete_intp(intp *self){ - if (self) delete self; -} -SWIGINTERN void intp_assign(intp *self,int value){ - *self = value; -} -SWIGINTERN int intp_value(intp *self){ - return *self; -} -SWIGINTERN int *intp_cast(intp *self){ - return self; -} -SWIGINTERN intp *intp_frompointer(int *t){ - return (intp *) t; -} - -typedef double doublep; - -SWIGINTERN doublep *new_doublep(){ - return new double(); -} -SWIGINTERN void delete_doublep(doublep *self){ - if (self) delete self; -} -SWIGINTERN void doublep_assign(doublep *self,double value){ - *self = value; -} -SWIGINTERN double doublep_value(doublep *self){ - return *self; -} -SWIGINTERN double *doublep_cast(doublep *self){ - return self; -} -SWIGINTERN doublep *doublep_frompointer(double *t){ - return (doublep *) t; -} - -typedef unsigned int uintp; - -SWIGINTERN uintp *new_uintp(){ - return new unsigned int(); -} -SWIGINTERN void delete_uintp(uintp *self){ - if (self) delete self; -} -SWIGINTERN void uintp_assign(uintp *self,unsigned int value){ - *self = value; -} -SWIGINTERN unsigned int uintp_value(uintp *self){ - return *self; -} -SWIGINTERN unsigned int *uintp_cast(uintp *self){ - return self; -} -SWIGINTERN uintp *uintp_frompointer(unsigned int *t){ - return (uintp *) t; -} - -typedef unsigned short ushortp; - -SWIGINTERN ushortp *new_ushortp(){ - return new unsigned short(); -} -SWIGINTERN void delete_ushortp(ushortp *self){ - if (self) delete self; -} -SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){ - *self = value; -} -SWIGINTERN unsigned short ushortp_value(ushortp *self){ - return *self; -} -SWIGINTERN unsigned short *ushortp_cast(ushortp *self){ - return self; -} -SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){ - return (ushortp *) t; -} - -unsigned int int_to_uint(int x) { - return (unsigned int) x; -} - - -using namespace Dali; -using namespace Dali::Toolkit; - -SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self) -{ - bool result = false; - try - { - // 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 mObjectHandle in BaseHandle; - if( *self ) - { - result = true; - } - else - { - result = false; - } - } - CALL_CATCH_EXCEPTION(false); - return result; -} - -SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs) -{ - bool result = false; - try - { - // C++ code. Check if two handles reference the same implemtion - if( *self == rhs) - { - result = true; - } - else - { - result = false; - } - } - CALL_CATCH_EXCEPTION(false); - return result; -} - - -SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){ - Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc ); - } -SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){ - Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc ); - } -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) { - pv = new std::vector< Dali::TouchPoint >(); - pv->reserve(capacity); - } else { - throw std::out_of_range("capacity"); - } - return pv; - } -SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){ - if (index>=0 && index<(int)self->size()) - return (*self)[index]; - else - throw std::out_of_range("index"); - } -SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){ - if (index>=0 && index<(int)self->size()) - return (*self)[index]; - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){ - if (index>=0 && index<(int)self->size()) - (*self)[index] = val; - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){ - self->insert(self->end(), values.begin(), values.end()); - } -SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){ - if (index < 0) - throw std::out_of_range("index"); - if (count < 0) - throw std::out_of_range("count"); - if (index >= (int)self->size()+1 || index+count > (int)self->size()) - throw std::invalid_argument("invalid range"); - return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count); - } -SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){ - if (index>=0 && index<(int)self->size()+1) - self->insert(self->begin()+index, x); - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){ - if (index>=0 && index<(int)self->size()+1) - self->insert(self->begin()+index, values.begin(), values.end()); - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){ - if (index>=0 && index<(int)self->size()) - self->erase(self->begin() + index); - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){ - if (index < 0) - throw std::out_of_range("index"); - if (count < 0) - throw std::out_of_range("count"); - if (index >= (int)self->size()+1 || index+count > (int)self->size()) - throw std::invalid_argument("invalid range"); - self->erase(self->begin()+index, self->begin()+index+count); - } -SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){ - if (count < 0) - throw std::out_of_range("count"); - return new std::vector< Dali::TouchPoint >(count, value); - } -SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){ - std::reverse(self->begin(), self->end()); - } -SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){ - if (index < 0) - throw std::out_of_range("index"); - if (count < 0) - throw std::out_of_range("count"); - if (index >= (int)self->size()+1 || index+count > (int)self->size()) - throw std::invalid_argument("invalid range"); - std::reverse(self->begin()+index, self->begin()+index+count); - } -SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){ - if (index < 0) - throw std::out_of_range("index"); - if (index+values.size() > self->size()) - throw std::out_of_range("index"); - std::copy(values.begin(), values.end(), self->begin()+index); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg1, arg2 ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchEvent const &) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchEvent const &) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchEvent const &) > *self,void (*func)(Dali::TouchEvent const &)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchEvent const &) > *self,void (*func)(Dali::TouchEvent const &)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchEvent const &) > *self,Dali::TouchEvent const &arg){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg1, arg2 ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg1, arg2 ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg1, arg2 ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){ - return self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){ - self->Emit( arg1, arg3 ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){ - return self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg1, arg2, arg3 ); - } - -SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){ - self->Disconnect( func ); - } -SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){ - return self->Emit(); - } - -SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){ - std::vector< unsigned int >* pv = 0; - if (capacity >= 0) { - pv = new std::vector< unsigned int >(); - pv->reserve(capacity); - } else { - throw std::out_of_range("capacity"); - } - return pv; - } -SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){ - if (index>=0 && index<(int)self->size()) - return (*self)[index]; - else - throw std::out_of_range("index"); - } -SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){ - if (index>=0 && index<(int)self->size()) - return (*self)[index]; - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){ - if (index>=0 && index<(int)self->size()) - (*self)[index] = val; - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){ - self->insert(self->end(), values.begin(), values.end()); - } -SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){ - if (index < 0) - throw std::out_of_range("index"); - if (count < 0) - throw std::out_of_range("count"); - if (index >= (int)self->size()+1 || index+count > (int)self->size()) - throw std::invalid_argument("invalid range"); - return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count); - } -SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){ - if (index>=0 && index<(int)self->size()+1) - self->insert(self->begin()+index, x); - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){ - if (index>=0 && index<(int)self->size()+1) - self->insert(self->begin()+index, values.begin(), values.end()); - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){ - if (index>=0 && index<(int)self->size()) - self->erase(self->begin() + index); - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){ - if (index < 0) - throw std::out_of_range("index"); - if (count < 0) - throw std::out_of_range("count"); - if (index >= (int)self->size()+1 || index+count > (int)self->size()) - throw std::invalid_argument("invalid range"); - self->erase(self->begin()+index, self->begin()+index+count); - } -SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){ - if (count < 0) - throw std::out_of_range("count"); - return new std::vector< unsigned int >(count, value); - } -SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){ - std::reverse(self->begin(), self->end()); - } -SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){ - if (index < 0) - throw std::out_of_range("index"); - if (count < 0) - throw std::out_of_range("count"); - if (index >= (int)self->size()+1 || index+count > (int)self->size()) - throw std::invalid_argument("invalid range"); - std::reverse(self->begin()+index, self->begin()+index+count); - } -SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){ - if (index < 0) - throw std::out_of_range("index"); - if (index+values.size() > self->size()) - throw std::out_of_range("index"); - std::copy(values.begin(), values.end(), self->begin()+index); - } -SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){ - return std::find(self->begin(), self->end(), value) != self->end(); - } -SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){ - int index = -1; - std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value); - if (it != self->end()) - index = (int)(it - self->begin()); - return index; - } -SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){ - int index = -1; - std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value); - if (rit != self->rend()) - index = (int)(self->rend() - 1 - rit); - return index; - } -SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){ - std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value); - if (it != self->end()) { - self->erase(it); - return true; - } - return false; - } -SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){ - std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0; - if (capacity >= 0) { - pv = new std::vector< std::pair< unsigned int,Dali::Actor > >(); - pv->reserve(capacity); - } else { - throw std::out_of_range("capacity"); - } - return pv; - } -SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){ - if (index>=0 && index<(int)self->size()) - return (*self)[index]; - else - throw std::out_of_range("index"); - } -SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){ - if (index>=0 && index<(int)self->size()) - return (*self)[index]; - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){ - if (index>=0 && index<(int)self->size()) - (*self)[index] = val; - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){ - self->insert(self->end(), values.begin(), values.end()); - } -SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){ - if (index < 0) - throw std::out_of_range("index"); - if (count < 0) - throw std::out_of_range("count"); - if (index >= (int)self->size()+1 || index+count > (int)self->size()) - throw std::invalid_argument("invalid range"); - return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count); - } -SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){ - if (index>=0 && index<(int)self->size()+1) - self->insert(self->begin()+index, x); - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){ - if (index>=0 && index<(int)self->size()+1) - self->insert(self->begin()+index, values.begin(), values.end()); - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){ - if (index>=0 && index<(int)self->size()) - self->erase(self->begin() + index); - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){ - if (index < 0) - throw std::out_of_range("index"); - if (count < 0) - throw std::out_of_range("count"); - if (index >= (int)self->size()+1 || index+count > (int)self->size()) - throw std::invalid_argument("invalid range"); - self->erase(self->begin()+index, self->begin()+index+count); - } -SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){ - if (count < 0) - throw std::out_of_range("count"); - return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value); - } -SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){ - std::reverse(self->begin(), self->end()); - } -SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){ - if (index < 0) - throw std::out_of_range("index"); - if (count < 0) - throw std::out_of_range("count"); - if (index >= (int)self->size()+1 || index+count > (int)self->size()) - throw std::invalid_argument("invalid range"); - std::reverse(self->begin()+index, self->begin()+index+count); - } -SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){ - if (index < 0) - throw std::out_of_range("index"); - if (index+values.size() > self->size()) - throw std::out_of_range("index"); - std::copy(values.begin(), values.end(), self->begin()+index); - } -SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){ - std::vector< Dali::Actor >* pv = 0; - if (capacity >= 0) { - pv = new std::vector< Dali::Actor >(); - pv->reserve(capacity); - } else { - throw std::out_of_range("capacity"); - } - return pv; - } -SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){ - if (index>=0 && index<(int)self->size()) - return (*self)[index]; - else - throw std::out_of_range("index"); - } -SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){ - if (index>=0 && index<(int)self->size()) - return (*self)[index]; - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){ - if (index>=0 && index<(int)self->size()) - (*self)[index] = val; - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){ - self->insert(self->end(), values.begin(), values.end()); - } -SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){ - if (index < 0) - throw std::out_of_range("index"); - if (count < 0) - throw std::out_of_range("count"); - if (index >= (int)self->size()+1 || index+count > (int)self->size()) - throw std::invalid_argument("invalid range"); - return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count); - } -SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){ - if (index>=0 && index<(int)self->size()+1) - self->insert(self->begin()+index, x); - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){ - if (index>=0 && index<(int)self->size()+1) - self->insert(self->begin()+index, values.begin(), values.end()); - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){ - if (index>=0 && index<(int)self->size()) - self->erase(self->begin() + index); - else - throw std::out_of_range("index"); - } -SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){ - if (index < 0) - throw std::out_of_range("index"); - if (count < 0) - throw std::out_of_range("count"); - if (index >= (int)self->size()+1 || index+count > (int)self->size()) - throw std::invalid_argument("invalid range"); - self->erase(self->begin()+index, self->begin()+index+count); - } -SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){ - if (count < 0) - throw std::out_of_range("count"); - return new std::vector< Dali::Actor >(count, value); - } -SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){ - std::reverse(self->begin(), self->end()); - } -SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){ - if (index < 0) - throw std::out_of_range("index"); - if (count < 0) - throw std::out_of_range("count"); - if (index >= (int)self->size()+1 || index+count > (int)self->size()) - throw std::invalid_argument("invalid range"); - std::reverse(self->begin()+index, self->begin()+index+count); - } -SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){ - if (index < 0) - throw std::out_of_range("index"); - if (index+values.size() > self->size()) - throw std::out_of_range("index"); - std::copy(values.begin(), values.end(), self->begin()+index); - } -SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){ - self->Disconnect( func ); - } -SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){ - return self->Emit( arg ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg1, arg2 ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg1, arg2 ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg1, arg2 ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg1, arg2 ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){ - return self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg1, arg2, arg3 ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg ); - } - - -SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){ - self->Disconnect( func ); - } -SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){ - return self->Emit( arg1, arg2 ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg ); - } -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){ - self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){ - self->Disconnect( func ); - } -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){ - /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/; -/*@SWIG@*/ self->Emit( arg ); - } - -/* --------------------------------------------------- - * C++ director class methods - * --------------------------------------------------- */ - -#include "dali-wrap.h" - -/* - * Widget director - */ -SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() { - swig_init_callbacks(); -} - -SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() { -} - -void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) { - char * jcontentInfo = 0 ; - void * jwindow ; - - if (!swig_callbackOnCreate) { - Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window); - return; - } else { - jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str()); - jwindow = (void *)new Dali::Window((const Dali::Window &)window); - swig_callbackOnCreate(jcontentInfo, jwindow); - } -} - -void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) { - char * jcontentInfo = 0 ; - int jtype ; - - if (!swig_callbackOnTerminate) { - Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type); - return; - } else { - jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str()); - jtype = (int)type; - swig_callbackOnTerminate(jcontentInfo, jtype); - } -} - -void SwigDirector_WidgetImpl::OnPause() { - if (!swig_callbackOnPause) { - Dali::Internal::Adaptor::Widget::OnPause(); - return; - } else { - swig_callbackOnPause(); - } -} - -void SwigDirector_WidgetImpl::OnResume() { - if (!swig_callbackOnResume) { - Dali::Internal::Adaptor::Widget::OnResume(); - return; - } else { - swig_callbackOnResume(); - } -} - -void SwigDirector_WidgetImpl::OnResize(Dali::Window window) { - void * jwindow ; - - if (!swig_callbackOnResize) { - Dali::Internal::Adaptor::Widget::OnResize(window); - return; - } else { - jwindow = (void *)new Dali::Window((const Dali::Window &)window); - swig_callbackOnResize(jwindow); - } -} - -void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) { - char * jcontentInfo = 0 ; - int jforce ; - - if (!swig_callbackOnUpdate) { - Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force); - return; - } else { - jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str()); - jforce = force; - swig_callbackOnUpdate(jcontentInfo, jforce); - } -} - -void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) { - void * jslotObserver = 0 ; - void * jcallback = 0 ; - - if (!swig_callbackSignalConnected) { - Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback); - return; - } else { - jslotObserver = (void *) slotObserver; - jcallback = (void *) callback; - swig_callbackSignalConnected(jslotObserver, jcallback); - } -} - -void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) { - void * jslotObserver = 0 ; - void * jcallback = 0 ; - - if (!swig_callbackSignalDisconnected) { - Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback); - return; - } else { - jslotObserver = (void *) slotObserver; - jcallback = (void *) callback; - swig_callbackSignalDisconnected(jslotObserver, jcallback); - } -} - -void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) { - - swig_callbackOnCreate = callbackOnCreate; - swig_callbackOnTerminate = callbackOnTerminate; - swig_callbackOnPause = callbackOnPause; - swig_callbackOnResume = callbackOnResume; - swig_callbackOnResize = callbackOnResize; - swig_callbackOnUpdate = callbackOnUpdate; - swig_callbackSignalConnected = callbackSignalConnected; - swig_callbackSignalDisconnected = callbackSignalDisconnected; -} - -void SwigDirector_WidgetImpl::swig_init_callbacks() { - swig_callbackOnCreate = 0; - swig_callbackOnTerminate = 0; - swig_callbackOnPause = 0; - swig_callbackOnResume = 0; - swig_callbackOnResize = 0; - swig_callbackOnUpdate = 0; - swig_callbackSignalConnected = 0; - swig_callbackSignalDisconnected = 0; -} - - -SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() { - swig_init_callbacks(); -} - -SwigDirector_ViewImpl::~SwigDirector_ViewImpl() { - -} - - -void SwigDirector_ViewImpl::OnSceneConnection(int depth) { - int jdepth ; - - if (!swig_callbackOnSceneConnection) { - Dali::Toolkit::Internal::Control::OnSceneConnection(depth); - return; - } else { - jdepth = depth; - swig_callbackOnSceneConnection(jdepth); - } -} - -void SwigDirector_ViewImpl::OnSceneDisconnection() { - if (!swig_callbackOnSceneDisconnection) { - Dali::Toolkit::Internal::Control::OnSceneDisconnection(); - return; - } else { - swig_callbackOnSceneDisconnection(); - } -} - -void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) { - void * jchild = 0 ; - - if (!swig_callbackOnChildAdd) { - Dali::Toolkit::Internal::Control::OnChildAdd(child); - return; - } else { - jchild = (Dali::Actor *) &child; - swig_callbackOnChildAdd(jchild); - } -} - -void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) { - void * jchild = 0 ; - - if (!swig_callbackOnChildRemove) { - Dali::Toolkit::Internal::Control::OnChildRemove(child); - return; - } else { - jchild = (Dali::Actor *) &child; - swig_callbackOnChildRemove(jchild); - } -} - -void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, const Dali::Property::Value& propertyValue) { - int jindex ; - void * jpropertyValue ; - - if (!swig_callbackOnPropertySet) { - Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue); - return; - } else { - jindex = index; - jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue); - swig_callbackOnPropertySet(jindex, jpropertyValue); - } -} - -void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) { - void * jtargetSize = 0 ; - - if (!swig_callbackOnSizeSet) { - Dali::Toolkit::Internal::Control::OnSizeSet(targetSize); - return; - } else { - jtargetSize = (Dali::Vector3 *) &targetSize; - swig_callbackOnSizeSet(jtargetSize); - } -} - -void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) { - void * janimation = 0 ; - void * jtargetSize = 0 ; - - if (!swig_callbackOnSizeAnimation) { - Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize); - return; - } else { - janimation = (Dali::Animation *) &animation; - jtargetSize = (Dali::Vector3 *) &targetSize; - swig_callbackOnSizeAnimation(janimation, jtargetSize); - } -} - -bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) { - bool c_result = SwigValueInit< bool >() ; - unsigned int jresult = 0 ; - void * jarg0 = 0 ; - - if (!swig_callbackOnKeyEvent) { - return Dali::Toolkit::Internal::Control::OnKeyEvent(event); - } else { - jarg0 = (Dali::KeyEvent *) &event; - jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0); - c_result = jresult ? true : false; - } - return c_result; -} - -void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) { - void * jsize = 0 ; - void * jcontainer = 0 ; - - if (!swig_callbackOnRelayout) { - Dali::Toolkit::Internal::Control::OnRelayout(size,container); - return; - } else { - jsize = (Dali::Vector2 *) &size; - jcontainer = (Dali::RelayoutContainer *) &container; - swig_callbackOnRelayout(jsize, jcontainer); - } -} - -void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) { - int jpolicy ; - int jdimension ; - - if (!swig_callbackOnSetResizePolicy) { - Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension); - return; - } else { - jpolicy = (int)policy; - jdimension = (int)dimension; - swig_callbackOnSetResizePolicy(jpolicy, jdimension); - } -} - -Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() { - Dali::Vector3 c_result ; - void * jresult = 0 ; - - if (!swig_callbackGetNaturalSize) { - return Dali::Toolkit::Internal::Control::GetNaturalSize(); - } else { - jresult = (void *) swig_callbackGetNaturalSize(); - if (!jresult) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0); - return c_result; - } - c_result = *(Dali::Vector3 *)jresult; - } - return c_result; -} - -float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) { - float c_result = SwigValueInit< float >() ; - float jresult = 0 ; - void * jchild = 0 ; - int jdimension ; - - if (!swig_callbackCalculateChildSize) { - return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension); - } else { - jchild = (Dali::Actor *) &child; - jdimension = (int)dimension; - jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension); - c_result = (float)jresult; - } - return c_result; -} - -float SwigDirector_ViewImpl::GetHeightForWidth(float width) { - float c_result = SwigValueInit< float >() ; - float jresult = 0 ; - float jwidth ; - - if (!swig_callbackGetHeightForWidth) { - return Dali::Toolkit::Internal::Control::GetHeightForWidth(width); - } else { - jwidth = width; - jresult = (float) swig_callbackGetHeightForWidth(jwidth); - c_result = (float)jresult; - } - return c_result; -} - -float SwigDirector_ViewImpl::GetWidthForHeight(float height) { - float c_result = SwigValueInit< float >() ; - float jresult = 0 ; - float jheight ; - - if (!swig_callbackGetWidthForHeight) { - return Dali::Toolkit::Internal::Control::GetWidthForHeight(height); - } else { - jheight = height; - jresult = (float) swig_callbackGetWidthForHeight(jheight); - c_result = (float)jresult; - } - return c_result; -} - -bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) { - bool c_result = SwigValueInit< bool >() ; - unsigned int jresult = 0 ; - int jdimension ; - - if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) { - return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension); - } else { - jdimension = (int)dimension; - jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension); - c_result = jresult ? true : false; - } - return c_result; -} - -void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) { - int jdimension ; - - if (!swig_callbackOnCalculateRelayoutSize) { - Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension); - return; - } else { - jdimension = (int)dimension; - swig_callbackOnCalculateRelayoutSize(jdimension); - } -} - -void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) { - float jsize ; - int jdimension ; - - if (!swig_callbackOnLayoutNegotiated) { - Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension); - return; - } else { - jsize = size; - jdimension = (int)dimension; - swig_callbackOnLayoutNegotiated(jsize, jdimension); - } -} - -Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() { - return Dali::CustomActorImpl::GetExtension(); -} - -void SwigDirector_ViewImpl::OnInitialize() { - if (!swig_callbackOnInitialize) { - Dali::Toolkit::Internal::Control::OnInitialize(); - return; - } else { - swig_callbackOnInitialize(); - } -} - -void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) { - void * jstyleManager ; - int jchange ; - - if (!swig_callbackOnStyleChange) { - Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change); - return; - } else { - jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager); - jchange = (int)change; - swig_callbackOnStyleChange(jstyleManager, jchange); - } -} - -bool SwigDirector_ViewImpl::OnAccessibilityActivated() { - bool c_result = SwigValueInit< bool >() ; - unsigned int jresult = 0 ; - - if (!swig_callbackOnAccessibilityActivated) { - return Dali::Toolkit::Internal::Control::OnAccessibilityActivated(); - } else { - jresult = (unsigned int) swig_callbackOnAccessibilityActivated(); - c_result = jresult ? true : false; - } - return c_result; -} - -bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) { - bool c_result = SwigValueInit< bool >() ; - unsigned int jresult = 0 ; - void * jgesture ; - - if (!swig_callbackOnAccessibilityPan) { - return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture); - } else { - jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture); - jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture); - c_result = jresult ? true : false; - } - return c_result; -} - -bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) { - bool c_result = SwigValueInit< bool >() ; - unsigned int jresult = 0 ; - unsigned int jisIncrease ; - - if (!swig_callbackOnAccessibilityValueChange) { - return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease); - } else { - jisIncrease = isIncrease; - jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease); - c_result = jresult ? true : false; - } - return c_result; -} - -bool SwigDirector_ViewImpl::OnAccessibilityZoom() { - bool c_result = SwigValueInit< bool >() ; - unsigned int jresult = 0 ; - - if (!swig_callbackOnAccessibilityZoom) { - return Dali::Toolkit::Internal::Control::OnAccessibilityZoom(); - } else { - jresult = (unsigned int) swig_callbackOnAccessibilityZoom(); - c_result = jresult ? true : false; - } - return c_result; -} - -void SwigDirector_ViewImpl::OnKeyInputFocusGained() { - if (!swig_callbackOnKeyInputFocusGained) { - Dali::Toolkit::Internal::Control::OnKeyInputFocusGained(); - return; - } else { - swig_callbackOnKeyInputFocusGained(); - } -} - -void SwigDirector_ViewImpl::OnKeyInputFocusLost() { - if (!swig_callbackOnKeyInputFocusLost) { - Dali::Toolkit::Internal::Control::OnKeyInputFocusLost(); - return; - } else { - swig_callbackOnKeyInputFocusLost(); - } -} - - -Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) -{ - Dali::Actor c_result; - void* jresult = 0; - - if(!swig_callbackGetNextKeyboardFocusableActor) - { - return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled); - } - else - { - jresult = (void*)swig_callbackGetNextKeyboardFocusableActor((void*)(¤tFocusedActor), (int)direction, loopEnabled); - - if(!jresult) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0); - return c_result; - } - c_result = *(Dali::Actor*)jresult; - } - return c_result; -} - -void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) -{ - if(!swig_callbackOnKeyboardFocusChangeCommitted) - { - Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor); - return; - } - else - { - swig_callbackOnKeyboardFocusChangeCommitted((void*)(&commitedFocusableActor)); - } -} - -bool SwigDirector_ViewImpl::OnKeyboardEnter() { - bool c_result = SwigValueInit< bool >() ; - unsigned int jresult = 0 ; - - if (!swig_callbackOnKeyboardEnter) { - return Dali::Toolkit::Internal::Control::OnKeyboardEnter(); - } else { - jresult = (unsigned int) swig_callbackOnKeyboardEnter(); - c_result = jresult ? true : false; - } - return c_result; -} - -void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) { - void * jpinch = 0 ; - - if (!swig_callbackOnPinch) { - Dali::Toolkit::Internal::Control::OnPinch(pinch); - return; - } else { - jpinch = (Dali::PinchGesture *) &pinch; - swig_callbackOnPinch(jpinch); - } -} - -void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) { - void * jpan = 0 ; - - if (!swig_callbackOnPan) { - Dali::Toolkit::Internal::Control::OnPan(pan); - return; - } else { - jpan = (Dali::PanGesture *) &pan; - swig_callbackOnPan(jpan); - } -} - -void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) { - void * jtap = 0 ; - - if (!swig_callbackOnTap) { - Dali::Toolkit::Internal::Control::OnTap(tap); - return; - } else { - jtap = (Dali::TapGesture *) &tap; - swig_callbackOnTap(jtap); - } -} - -void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) { - void * jlongPress = 0 ; - - if (!swig_callbackOnLongPress) { - Dali::Toolkit::Internal::Control::OnLongPress(longPress); - return; - } else { - jlongPress = (Dali::LongPressGesture *) &longPress; - swig_callbackOnLongPress(jlongPress); - } -} - -void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) { - void * jslotObserver = 0 ; - void * jcallback = 0 ; - - if (!swig_callbackSignalConnected) { - Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback); - return; - } else { - jslotObserver = (void *) slotObserver; - jcallback = (void *) callback; - swig_callbackSignalConnected(jslotObserver, jcallback); - } -} - -void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) { - void * jslotObserver = 0 ; - void * jcallback = 0 ; - - if (!swig_callbackSignalDisconnected) { - Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback); - return; - } else { - jslotObserver = (void *) slotObserver; - jcallback = (void *) callback; - swig_callbackSignalDisconnected(jslotObserver, jcallback); - } -} - -Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() { - return Dali::Toolkit::Internal::Control::GetControlExtension(); -} - -void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnSceneConnection, SWIG_Callback1_t callbackOnSceneDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) { - swig_callbackOnSceneConnection = callbackOnSceneConnection; - swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection; - swig_callbackOnChildAdd = callbackOnChildAdd; - swig_callbackOnChildRemove = callbackOnChildRemove; - swig_callbackOnPropertySet = callbackOnPropertySet; - swig_callbackOnSizeSet = callbackOnSizeSet; - swig_callbackOnSizeAnimation = callbackOnSizeAnimation; - swig_callbackOnKeyEvent = callbackOnKeyEvent; - swig_callbackOnRelayout = callbackOnRelayout; - swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy; - swig_callbackGetNaturalSize = callbackGetNaturalSize; - swig_callbackCalculateChildSize = callbackCalculateChildSize; - swig_callbackGetHeightForWidth = callbackGetHeightForWidth; - swig_callbackGetWidthForHeight = callbackGetWidthForHeight; - swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0; - swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1; - swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize; - swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated; - swig_callbackOnInitialize = callbackOnInitialize; - swig_callbackOnStyleChange = callbackOnStyleChange; - swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated; - swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan; - swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange; - swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom; - swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained; - swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost; - swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor; - swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted; - swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter; - swig_callbackOnPinch = callbackOnPinch; - swig_callbackOnPan = callbackOnPan; - swig_callbackOnTap = callbackOnTap; - swig_callbackOnLongPress = callbackOnLongPress; - swig_callbackSignalConnected = callbackSignalConnected; - swig_callbackSignalDisconnected = callbackSignalDisconnected; -} - -void SwigDirector_ViewImpl::swig_init_callbacks() { - swig_callbackOnSceneConnection = 0; - swig_callbackOnSceneDisconnection = 0; - swig_callbackOnChildAdd = 0; - swig_callbackOnChildRemove = 0; - swig_callbackOnPropertySet = 0; - swig_callbackOnSizeSet = 0; - swig_callbackOnSizeAnimation = 0; - swig_callbackOnKeyEvent = 0; - swig_callbackOnRelayout = 0; - swig_callbackOnSetResizePolicy = 0; - swig_callbackGetNaturalSize = 0; - swig_callbackCalculateChildSize = 0; - swig_callbackGetHeightForWidth = 0; - swig_callbackGetWidthForHeight = 0; - swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0; - swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0; - swig_callbackOnCalculateRelayoutSize = 0; - swig_callbackOnLayoutNegotiated = 0; - swig_callbackOnInitialize = 0; - swig_callbackOnStyleChange = 0; - swig_callbackOnAccessibilityActivated = 0; - swig_callbackOnAccessibilityPan = 0; - swig_callbackOnAccessibilityValueChange = 0; - swig_callbackOnAccessibilityZoom = 0; - swig_callbackOnKeyInputFocusGained = 0; - swig_callbackOnKeyInputFocusLost = 0; - swig_callbackGetNextKeyboardFocusableActor = 0; - swig_callbackOnKeyboardFocusChangeCommitted = 0; - swig_callbackOnKeyboardEnter = 0; - swig_callbackOnPinch = 0; - swig_callbackOnPan = 0; - swig_callbackOnTap = 0; - swig_callbackOnLongPress = 0; - swig_callbackSignalConnected = 0; - swig_callbackSignalDisconnected = 0; -} - -SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() { - swig_init_callbacks(); -} - -SwigDirector_ItemFactory::~SwigDirector_ItemFactory() { - -} - - -unsigned int SwigDirector_ItemFactory::GetNumberOfItems() { - unsigned int c_result = SwigValueInit< unsigned int >() ; - unsigned int jresult = 0 ; - - if (!swig_callbackGetNumberOfItems) { - throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems"); - } else { - jresult = (unsigned int) swig_callbackGetNumberOfItems(); - c_result = (unsigned int)jresult; - } - return c_result; -} - -Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) { - Dali::Actor c_result ; - void * jresult = 0 ; - unsigned int jitemId ; - - if (!swig_callbackNewItem) { - throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem"); - } else { - jitemId = itemId; - jresult = (void *) swig_callbackNewItem(jitemId); - if (!jresult) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0); - return c_result; - } - c_result = *(Dali::Actor *)jresult; - } - return c_result; -} - -void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) -{ - if(!swig_callbackItemReleased) - { - Dali::Toolkit::ItemFactory::ItemReleased(itemId, actor); - return; - } - else - { - swig_callbackItemReleased(itemId, (void*)(&actor)); - } -} - -Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() { - return Dali::Toolkit::ItemFactory::GetExtension(); -} - -void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) { - swig_callbackGetNumberOfItems = callbackGetNumberOfItems; - swig_callbackNewItem = callbackNewItem; - swig_callbackItemReleased = callbackItemReleased; -} - -void SwigDirector_ItemFactory::swig_init_callbacks() { - swig_callbackGetNumberOfItems = 0; - swig_callbackNewItem = 0; - swig_callbackItemReleased = 0; -} - -SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() { - swig_init_callbacks(); -} - -SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() { - -} - - -Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction, const std::string& deviceName) -{ - Dali::Actor c_result; - void* jresult = 0; - - if(!swig_callbackGetNextFocusableActor) - { - throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor"); - } - else - { - jresult = (void*)swig_callbackGetNextFocusableActor((void*)(¤t), (void*)(&proposed), direction, deviceName.c_str()); - if(!jresult) - { - DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::Actor! Next focus will be NULL, please be cautious to handle the keyboard foucs!", __FILE__, __LINE__); - return c_result; - } - c_result = *(Dali::Actor*)jresult; - } - return c_result; -} - -void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) { - swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor; -} - -void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() { - swig_callbackGetNextFocusableActor = 0; -} - -SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() { - swig_callbackOnUpdate = 0; -} - -SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() { - -} - -void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) { - swig_callbackOnUpdate = callbackUpdate; -} - - -bool SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) { - void * jcurrent ; - - if (!swig_callbackOnUpdate) { - throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update"); - } else { - Dali::UpdateProxy* proxy = &updateProxy; - jcurrent = (void *)proxy; - swig_callbackOnUpdate(jcurrent, elapsedSeconds); - if (!jcurrent) { - DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__); - return false; - } - } - return false; -} - - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() { - void * jresult ; - floatp *result = 0 ; - - { - try { - result = (floatp *)new_floatp(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) { - floatp *arg1 = (floatp *) 0 ; - - arg1 = (floatp *)jarg1; - { - try { - delete_floatp(arg1); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) { - floatp *arg1 = (floatp *) 0 ; - float arg2 ; - - arg1 = (floatp *)jarg1; - arg2 = (float)jarg2; - { - try { - floatp_assign(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) { - float jresult ; - floatp *arg1 = (floatp *) 0 ; - float result; - - arg1 = (floatp *)jarg1; - { - try { - result = (float)floatp_value(arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) { - void * jresult ; - floatp *arg1 = (floatp *) 0 ; - float *result = 0 ; - - arg1 = (floatp *)jarg1; - { - try { - result = (float *)floatp_cast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) { - void * jresult ; - float *arg1 = (float *) 0 ; - floatp *result = 0 ; - - arg1 = (float *)jarg1; - { - try { - result = (floatp *)floatp_frompointer(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() { - void * jresult ; - intp *result = 0 ; - - { - try { - result = (intp *)new_intp(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) { - intp *arg1 = (intp *) 0 ; - - arg1 = (intp *)jarg1; - { - try { - delete_intp(arg1); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) { - intp *arg1 = (intp *) 0 ; - int arg2 ; - - arg1 = (intp *)jarg1; - arg2 = (int)jarg2; - { - try { - intp_assign(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) { - int jresult ; - intp *arg1 = (intp *) 0 ; - int result; - - arg1 = (intp *)jarg1; - { - try { - result = (int)intp_value(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) { - void * jresult ; - intp *arg1 = (intp *) 0 ; - int *result = 0 ; - - arg1 = (intp *)jarg1; - { - try { - result = (int *)intp_cast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) { - void * jresult ; - int *arg1 = (int *) 0 ; - intp *result = 0 ; - - arg1 = (int *)jarg1; - { - try { - result = (intp *)intp_frompointer(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() { - void * jresult ; - doublep *result = 0 ; - - { - try { - result = (doublep *)new_doublep(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) { - doublep *arg1 = (doublep *) 0 ; - - arg1 = (doublep *)jarg1; - { - try { - delete_doublep(arg1); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) { - doublep *arg1 = (doublep *) 0 ; - double arg2 ; - - arg1 = (doublep *)jarg1; - arg2 = (double)jarg2; - { - try { - doublep_assign(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) { - double jresult ; - doublep *arg1 = (doublep *) 0 ; - double result; - - arg1 = (doublep *)jarg1; - { - try { - result = (double)doublep_value(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) { - void * jresult ; - doublep *arg1 = (doublep *) 0 ; - double *result = 0 ; - - arg1 = (doublep *)jarg1; - { - try { - result = (double *)doublep_cast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) { - void * jresult ; - double *arg1 = (double *) 0 ; - doublep *result = 0 ; - - arg1 = (double *)jarg1; - { - try { - result = (doublep *)doublep_frompointer(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() { - void * jresult ; - uintp *result = 0 ; - - { - try { - result = (uintp *)new_uintp(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) { - uintp *arg1 = (uintp *) 0 ; - - arg1 = (uintp *)jarg1; - { - try { - delete_uintp(arg1); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) { - uintp *arg1 = (uintp *) 0 ; - unsigned int arg2 ; - - arg1 = (uintp *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - uintp_assign(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) { - unsigned int jresult ; - uintp *arg1 = (uintp *) 0 ; - unsigned int result; - - arg1 = (uintp *)jarg1; - { - try { - result = (unsigned int)uintp_value(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) { - void * jresult ; - uintp *arg1 = (uintp *) 0 ; - unsigned int *result = 0 ; - - arg1 = (uintp *)jarg1; - { - try { - result = (unsigned int *)uintp_cast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) { - void * jresult ; - unsigned int *arg1 = (unsigned int *) 0 ; - uintp *result = 0 ; - - arg1 = (unsigned int *)jarg1; - { - try { - result = (uintp *)uintp_frompointer(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() { - void * jresult ; - ushortp *result = 0 ; - - { - try { - result = (ushortp *)new_ushortp(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) { - ushortp *arg1 = (ushortp *) 0 ; - - arg1 = (ushortp *)jarg1; - { - try { - delete_ushortp(arg1); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) { - ushortp *arg1 = (ushortp *) 0 ; - unsigned short arg2 ; - - arg1 = (ushortp *)jarg1; - arg2 = (unsigned short)jarg2; - { - try { - ushortp_assign(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) { - unsigned short jresult ; - ushortp *arg1 = (ushortp *) 0 ; - unsigned short result; - - arg1 = (ushortp *)jarg1; - { - try { - result = (unsigned short)ushortp_value(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) { - void * jresult ; - ushortp *arg1 = (ushortp *) 0 ; - unsigned short *result = 0 ; - - arg1 = (ushortp *)jarg1; - { - try { - result = (unsigned short *)ushortp_cast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) { - void * jresult ; - unsigned short *arg1 = (unsigned short *) 0 ; - ushortp *result = 0 ; - - arg1 = (unsigned short *)jarg1; - { - try { - result = (ushortp *)ushortp_frompointer(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) { - unsigned int jresult ; - int arg1 ; - unsigned int result; - - arg1 = (int)jarg1; - { - try { - result = (unsigned int)int_to_uint(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) { - Dali::RefObject *arg1 = (Dali::RefObject *) 0 ; - - arg1 = (Dali::RefObject *)jarg1; - { - try { - (arg1)->Reference(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) { - Dali::RefObject *arg1 = (Dali::RefObject *) 0 ; - - arg1 = (Dali::RefObject *)jarg1; - { - try { - (arg1)->Unreference(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) { - int jresult ; - Dali::RefObject *arg1 = (Dali::RefObject *) 0 ; - int result; - - arg1 = (Dali::RefObject *)jarg1; - { - try { - result = (int)(arg1)->ReferenceCount(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() { - void * jresult ; - Dali::Any *result = 0 ; - - { - try { - result = (Dali::Any *)new Dali::Any(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) { - Dali::Any *arg1 = (Dali::Any *) 0 ; - - arg1 = (Dali::Any *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) { - char *arg1 = (char *) 0 ; - - arg1 = (char *)jarg1; - { - try { - Dali::Any::AssertAlways((char const *)arg1); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) { - void * jresult ; - Dali::Any *arg1 = 0 ; - Dali::Any *result = 0 ; - - arg1 = (Dali::Any *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Any *arg1 = (Dali::Any *) 0 ; - Dali::Any *arg2 = 0 ; - Dali::Any *result = 0 ; - - arg1 = (Dali::Any *)jarg1; - arg2 = (Dali::Any *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) { - void * jresult ; - Dali::Any *arg1 = (Dali::Any *) 0 ; - std::type_info *result = 0 ; - - arg1 = (Dali::Any *)jarg1; - { - try { - result = (std::type_info *) &((Dali::Any const *)arg1)->GetType(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) { - bool jresult ; - Dali::Any *arg1 = (Dali::Any *) 0 ; - bool result; - - arg1 = (Dali::Any *)jarg1; - { - try { - result = (bool)((Dali::Any const *)arg1)->Empty(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) { - char *arg1 = (char *) 0 ; - char *arg2 = (char *) 0 ; - - arg1 = (char *)jarg1; - arg2 = (char *)jarg2; - { - try { - Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) { - void * jresult ; - char *arg1 = (char *) 0 ; - char *arg2 = (char *) 0 ; - Dali::DaliException *result = 0 ; - - arg1 = (char *)jarg1; - arg2 = (char *)jarg2; - { - try { - result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) { - Dali::DaliException *arg1 = (Dali::DaliException *) 0 ; - std::string arg2 = std::string(jarg2); - - arg1 = (Dali::DaliException *)jarg1; - { - if (!arg2.empty()) { - ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0'; - } else { - arg1->location = 0; - } - } -} - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) { - char * jresult ; - Dali::DaliException *arg1 = (Dali::DaliException *) 0 ; - char *result = 0 ; - - arg1 = (Dali::DaliException *)jarg1; - result = (char *) ((arg1)->location); - jresult = SWIG_csharp_string_callback((const char *)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) { - Dali::DaliException *arg1 = (Dali::DaliException *) 0 ; - std::string arg2 = std::string(jarg2); - - arg1 = (Dali::DaliException *)jarg1; - { - if (!arg2.empty()) { - ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0'; - } else { - arg1->condition = 0; - } - } -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) { - char * jresult ; - Dali::DaliException *arg1 = (Dali::DaliException *) 0 ; - char *result = 0 ; - - arg1 = (Dali::DaliException *)jarg1; - result = (char *) ((arg1)->condition); - jresult = SWIG_csharp_string_callback((const char *)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) { - Dali::DaliException *arg1 = (Dali::DaliException *) 0 ; - - arg1 = (Dali::DaliException *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() { - void * jresult ; - Dali::Vector2 *result = 0 ; - - { - try { - result = (Dali::Vector2 *)new Dali::Vector2(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) { - void * jresult ; - float arg1 ; - float arg2 ; - Dali::Vector2 *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - { - try { - result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) { - void * jresult ; - float *arg1 = (float *) 0 ; - Dali::Vector2 *result = 0 ; - - arg1 = jarg1; - { - try { - result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) { - void * jresult ; - Dali::Vector3 *arg1 = 0 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) { - void * jresult ; - Dali::Vector4 *arg1 = 0 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::Vector4 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() { - void * jresult ; - Dali::Vector2 *result = 0 ; - - result = (Dali::Vector2 *)&Dali::Vector2::ONE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() { - void * jresult ; - Dali::Vector2 *result = 0 ; - - result = (Dali::Vector2 *)&Dali::Vector2::XAXIS; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() { - void * jresult ; - Dali::Vector2 *result = 0 ; - - result = (Dali::Vector2 *)&Dali::Vector2::YAXIS; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() { - void * jresult ; - Dali::Vector2 *result = 0 ; - - result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() { - void * jresult ; - Dali::Vector2 *result = 0 ; - - result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() { - void * jresult ; - Dali::Vector2 *result = 0 ; - - result = (Dali::Vector2 *)&Dali::Vector2::ZERO; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) { - void * jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - float *arg2 = (float *) 0 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = jarg2; - { - try { - result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - Dali::Vector4 *arg2 = 0 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - Dali::Vector2 *arg2 = 0 ; - Dali::Vector2 result; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - Dali::Vector2 *arg2 = 0 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - Dali::Vector2 *arg2 = 0 ; - Dali::Vector2 result; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - Dali::Vector2 *arg2 = 0 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - Dali::Vector2 *arg2 = 0 ; - Dali::Vector2 result; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) { - void * jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - float arg2 ; - Dali::Vector2 result; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (float)jarg2; - { - try { - result = ((Dali::Vector2 const *)arg1)->operator *(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - Dali::Vector2 *arg2 = 0 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) { - void * jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - float arg2 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (float)jarg2; - { - try { - result = (Dali::Vector2 *) &(arg1)->operator *=(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - Dali::Vector2 *arg2 = 0 ; - Dali::Vector2 result; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) { - void * jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - float arg2 ; - Dali::Vector2 result; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (float)jarg2; - { - try { - result = ((Dali::Vector2 const *)arg1)->operator /(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - Dali::Vector2 *arg2 = 0 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) { - void * jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - float arg2 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (float)jarg2; - { - try { - result = (Dali::Vector2 *) &(arg1)->operator /=(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::Vector2 *)jarg1; - { - try { - result = ((Dali::Vector2 const *)arg1)->operator -(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - Dali::Vector2 *arg2 = 0 ; - bool result; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - Dali::Vector2 *arg2 = 0 ; - bool result; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) { - float jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - unsigned int arg2 ; - float *result = 0 ; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = *result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) { - float jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - float result; - - arg1 = (Dali::Vector2 *)jarg1; - { - try { - result = (float)((Dali::Vector2 const *)arg1)->Length(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) { - float jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - float result; - - arg1 = (Dali::Vector2 *)jarg1; - { - try { - result = (float)((Dali::Vector2 const *)arg1)->LengthSquared(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) { - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - - arg1 = (Dali::Vector2 *)jarg1; - { - try { - (arg1)->Normalize(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) { - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - Dali::Vector2 *arg2 = 0 ; - Dali::Vector2 *arg3 = 0 ; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - arg3 = (Dali::Vector2 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - { - try { - (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) { - void * jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - float *result = 0 ; - - arg1 = (Dali::Vector2 *)jarg1; - { - try { - result = (float *)((Dali::Vector2 const *)arg1)->AsFloat(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) { - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->x = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) { - float jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - float result; - - arg1 = (Dali::Vector2 *)jarg1; - result = (float) ((arg1)->x); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) { - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->width = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) { - float jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - float result; - - arg1 = (Dali::Vector2 *)jarg1; - result = (float) ((arg1)->width); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) { - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->y = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) { - float jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - float result; - - arg1 = (Dali::Vector2 *)jarg1; - result = (float) ((arg1)->y); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) { - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector2 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->height = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) { - float jresult ; - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - float result; - - arg1 = (Dali::Vector2 *)jarg1; - result = (float) ((arg1)->height); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) { - Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ; - - arg1 = (Dali::Vector2 *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector2 *arg1 = 0 ; - Dali::Vector2 *arg2 = 0 ; - Dali::Vector2 result; - - arg1 = (Dali::Vector2 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector2 *arg1 = 0 ; - Dali::Vector2 *arg2 = 0 ; - Dali::Vector2 result; - - arg1 = (Dali::Vector2 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) { - void * jresult ; - Dali::Vector2 *arg1 = 0 ; - float *arg2 = 0 ; - float *arg3 = 0 ; - float temp2 ; - float temp3 ; - Dali::Vector2 result; - - arg1 = (Dali::Vector2 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - temp2 = (float)jarg2; - arg2 = &temp2; - temp3 = (float)jarg3; - arg3 = &temp3; - { - try { - result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - { - try { - result = (Dali::Vector3 *)new Dali::Vector3(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) { - void * jresult ; - float arg1 ; - float arg2 ; - float arg3 ; - Dali::Vector3 *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - { - try { - result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) { - void * jresult ; - float *arg1 = (float *) 0 ; - Dali::Vector3 *result = 0 ; - - arg1 = jarg1; - { - try { - result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) { - void * jresult ; - Dali::Vector2 *arg1 = 0 ; - Dali::Vector3 *result = 0 ; - - arg1 = (Dali::Vector2 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) { - void * jresult ; - Dali::Vector4 *arg1 = 0 ; - Dali::Vector3 *result = 0 ; - - arg1 = (Dali::Vector4 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::Vector3::ONE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::Vector3::XAXIS; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::Vector3::YAXIS; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::Vector3::ZERO; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float *arg2 = (float *) 0 ; - Dali::Vector3 *result = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = jarg2; - { - try { - result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - Dali::Vector2 *arg2 = 0 ; - Dali::Vector3 *result = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - Dali::Vector4 *arg2 = 0 ; - Dali::Vector3 *result = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Vector3 result; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Vector3 *result = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Vector3 result; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Vector3 *result = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Vector3 result; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float arg2 ; - Dali::Vector3 result; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (float)jarg2; - { - try { - result = ((Dali::Vector3 const *)arg1)->operator *(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Vector3 *result = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float arg2 ; - Dali::Vector3 *result = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (float)jarg2; - { - try { - result = (Dali::Vector3 *) &(arg1)->operator *=(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - Dali::Quaternion *arg2 = 0 ; - Dali::Vector3 *result = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (Dali::Quaternion *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Vector3 result; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float arg2 ; - Dali::Vector3 result; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (float)jarg2; - { - try { - result = ((Dali::Vector3 const *)arg1)->operator /(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Vector3 *result = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float arg2 ; - Dali::Vector3 *result = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (float)jarg2; - { - try { - result = (Dali::Vector3 *) &(arg1)->operator /=(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - Dali::Vector3 result; - - arg1 = (Dali::Vector3 *)jarg1; - { - try { - result = ((Dali::Vector3 const *)arg1)->operator -(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - Dali::Vector3 *arg2 = 0 ; - bool result; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - Dali::Vector3 *arg2 = 0 ; - bool result; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) { - float jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - unsigned int arg2 ; - float *result = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = *result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) { - float jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - Dali::Vector3 *arg2 = 0 ; - float result; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Vector3 result; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) { - float jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float result; - - arg1 = (Dali::Vector3 *)jarg1; - { - try { - result = (float)((Dali::Vector3 const *)arg1)->Length(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) { - float jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float result; - - arg1 = (Dali::Vector3 *)jarg1; - { - try { - result = (float)((Dali::Vector3 const *)arg1)->LengthSquared(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) { - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - { - try { - (arg1)->Normalize(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) { - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Vector3 *arg3 = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - arg3 = (Dali::Vector3 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - { - try { - (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float *result = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - { - try { - result = (float *)((Dali::Vector3 const *)arg1)->AsFloat(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - { - try { - result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) { - void * jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - { - try { - result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) { - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->x = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) { - float jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float result; - - arg1 = (Dali::Vector3 *)jarg1; - result = (float) ((arg1)->x); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) { - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->width = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) { - float jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float result; - - arg1 = (Dali::Vector3 *)jarg1; - result = (float) ((arg1)->width); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) { - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->r = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) { - float jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float result; - - arg1 = (Dali::Vector3 *)jarg1; - result = (float) ((arg1)->r); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) { - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->y = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) { - float jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float result; - - arg1 = (Dali::Vector3 *)jarg1; - result = (float) ((arg1)->y); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) { - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->height = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) { - float jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float result; - - arg1 = (Dali::Vector3 *)jarg1; - result = (float) ((arg1)->height); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) { - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->g = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) { - float jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float result; - - arg1 = (Dali::Vector3 *)jarg1; - result = (float) ((arg1)->g); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) { - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->z = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) { - float jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float result; - - arg1 = (Dali::Vector3 *)jarg1; - result = (float) ((arg1)->z); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) { - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->depth = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) { - float jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float result; - - arg1 = (Dali::Vector3 *)jarg1; - result = (float) ((arg1)->depth); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) { - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector3 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->b = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) { - float jresult ; - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - float result; - - arg1 = (Dali::Vector3 *)jarg1; - result = (float) ((arg1)->b); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) { - Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector3 *arg1 = 0 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Vector3 result; - - arg1 = (Dali::Vector3 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector3 *arg1 = 0 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Vector3 result; - - arg1 = (Dali::Vector3 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) { - void * jresult ; - Dali::Vector3 *arg1 = 0 ; - float *arg2 = 0 ; - float *arg3 = 0 ; - float temp2 ; - float temp3 ; - Dali::Vector3 result; - - arg1 = (Dali::Vector3 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - temp2 = (float)jarg2; - arg2 = &temp2; - temp3 = (float)jarg3; - arg3 = &temp3; - { - try { - result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() { - void * jresult ; - Dali::Vector4 *result = 0 ; - - { - try { - result = (Dali::Vector4 *)new Dali::Vector4(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) { - void * jresult ; - float arg1 ; - float arg2 ; - float arg3 ; - float arg4 ; - Dali::Vector4 *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - { - try { - result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) { - void * jresult ; - float *arg1 = (float *) 0 ; - Dali::Vector4 *result = 0 ; - - arg1 = jarg1; - { - try { - result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) { - void * jresult ; - Dali::Vector2 *arg1 = 0 ; - Dali::Vector4 *result = 0 ; - - arg1 = (Dali::Vector2 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) { - void * jresult ; - Dali::Vector3 *arg1 = 0 ; - Dali::Vector4 *result = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() { - void * jresult ; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Vector4::ONE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() { - void * jresult ; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Vector4::XAXIS; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() { - void * jresult ; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Vector4::YAXIS; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() { - void * jresult ; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() { - void * jresult ; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Vector4::ZERO; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) { - void * jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float *arg2 = (float *) 0 ; - Dali::Vector4 *result = 0 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = jarg2; - { - try { - result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - Dali::Vector2 *arg2 = 0 ; - Dali::Vector4 *result = 0 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Vector4 *result = 0 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - Dali::Vector4 *arg2 = 0 ; - Dali::Vector4 result; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - Dali::Vector4 *arg2 = 0 ; - Dali::Vector4 *result = 0 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - Dali::Vector4 *arg2 = 0 ; - Dali::Vector4 result; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - Dali::Vector4 *arg2 = 0 ; - Dali::Vector4 *result = 0 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - Dali::Vector4 *arg2 = 0 ; - Dali::Vector4 result; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) { - void * jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float arg2 ; - Dali::Vector4 result; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (float)jarg2; - { - try { - result = ((Dali::Vector4 const *)arg1)->operator *(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - Dali::Vector4 *arg2 = 0 ; - Dali::Vector4 *result = 0 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) { - void * jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float arg2 ; - Dali::Vector4 *result = 0 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (float)jarg2; - { - try { - result = (Dali::Vector4 *) &(arg1)->operator *=(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - Dali::Vector4 *arg2 = 0 ; - Dali::Vector4 result; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) { - void * jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float arg2 ; - Dali::Vector4 result; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (float)jarg2; - { - try { - result = ((Dali::Vector4 const *)arg1)->operator /(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - Dali::Vector4 *arg2 = 0 ; - Dali::Vector4 *result = 0 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) { - void * jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float arg2 ; - Dali::Vector4 *result = 0 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (float)jarg2; - { - try { - result = (Dali::Vector4 *) &(arg1)->operator /=(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - Dali::Vector4 result; - - arg1 = (Dali::Vector4 *)jarg1; - { - try { - result = ((Dali::Vector4 const *)arg1)->operator -(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - Dali::Vector4 *arg2 = 0 ; - bool result; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - Dali::Vector4 *arg2 = 0 ; - bool result; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) { - float jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - unsigned int arg2 ; - float *result = 0 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = *result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) { - float jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - Dali::Vector3 *arg2 = 0 ; - float result; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) { - float jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - Dali::Vector4 *arg2 = 0 ; - float result; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) { - float jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - Dali::Vector4 *arg2 = 0 ; - float result; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - Dali::Vector4 *arg2 = 0 ; - Dali::Vector4 result; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) { - float jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float result; - - arg1 = (Dali::Vector4 *)jarg1; - { - try { - result = (float)((Dali::Vector4 const *)arg1)->Length(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) { - float jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float result; - - arg1 = (Dali::Vector4 *)jarg1; - { - try { - result = (float)((Dali::Vector4 const *)arg1)->LengthSquared(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) { - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - - arg1 = (Dali::Vector4 *)jarg1; - { - try { - (arg1)->Normalize(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) { - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - Dali::Vector4 *arg2 = 0 ; - Dali::Vector4 *arg3 = 0 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return ; - } - arg3 = (Dali::Vector4 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return ; - } - { - try { - (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) { - void * jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float *result = 0 ; - - arg1 = (Dali::Vector4 *)jarg1; - { - try { - result = (float *)((Dali::Vector4 const *)arg1)->AsFloat(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) { - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->x = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) { - float jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float result; - - arg1 = (Dali::Vector4 *)jarg1; - result = (float) ((arg1)->x); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) { - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->r = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) { - float jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float result; - - arg1 = (Dali::Vector4 *)jarg1; - result = (float) ((arg1)->r); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) { - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->s = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) { - float jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float result; - - arg1 = (Dali::Vector4 *)jarg1; - result = (float) ((arg1)->s); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) { - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->y = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) { - float jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float result; - - arg1 = (Dali::Vector4 *)jarg1; - result = (float) ((arg1)->y); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) { - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->g = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) { - float jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float result; - - arg1 = (Dali::Vector4 *)jarg1; - result = (float) ((arg1)->g); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) { - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->t = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) { - float jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float result; - - arg1 = (Dali::Vector4 *)jarg1; - result = (float) ((arg1)->t); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) { - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->z = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) { - float jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float result; - - arg1 = (Dali::Vector4 *)jarg1; - result = (float) ((arg1)->z); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) { - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->b = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) { - float jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float result; - - arg1 = (Dali::Vector4 *)jarg1; - result = (float) ((arg1)->b); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) { - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->p = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) { - float jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float result; - - arg1 = (Dali::Vector4 *)jarg1; - result = (float) ((arg1)->p); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) { - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->w = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) { - float jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float result; - - arg1 = (Dali::Vector4 *)jarg1; - result = (float) ((arg1)->w); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) { - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->a = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) { - float jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float result; - - arg1 = (Dali::Vector4 *)jarg1; - result = (float) ((arg1)->a); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) { - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float arg2 ; - - arg1 = (Dali::Vector4 *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->q = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) { - float jresult ; - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - float result; - - arg1 = (Dali::Vector4 *)jarg1; - result = (float) ((arg1)->q); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) { - Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ; - - arg1 = (Dali::Vector4 *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector4 *arg1 = 0 ; - Dali::Vector4 *arg2 = 0 ; - Dali::Vector4 result; - - arg1 = (Dali::Vector4 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector4 *arg1 = 0 ; - Dali::Vector4 *arg2 = 0 ; - Dali::Vector4 result; - - arg1 = (Dali::Vector4 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) { - void * jresult ; - Dali::Vector4 *arg1 = 0 ; - float *arg2 = 0 ; - float *arg3 = 0 ; - float temp2 ; - float temp3 ; - Dali::Vector4 result; - - arg1 = (Dali::Vector4 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - temp2 = (float)jarg2; - arg2 = &temp2; - temp3 = (float)jarg3; - arg3 = &temp3; - { - try { - result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() { - void * jresult ; - Dali::Uint16Pair *result = 0 ; - - { - try { - result = (Dali::Uint16Pair *)new Dali::Uint16Pair(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) { - void * jresult ; - uint32_t arg1 ; - uint32_t arg2 ; - Dali::Uint16Pair *result = 0 ; - - arg1 = (uint32_t)jarg1; - arg2 = (uint32_t)jarg2; - { - try { - result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) { - void * jresult ; - Dali::Uint16Pair *arg1 = 0 ; - Dali::Uint16Pair *result = 0 ; - - arg1 = (Dali::Uint16Pair *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) { - Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; - uint16_t arg2 ; - - arg1 = (Dali::Uint16Pair *)jarg1; - arg2 = (uint16_t)jarg2; - { - try { - (arg1)->SetWidth(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) { - unsigned short jresult ; - Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; - uint16_t result; - - arg1 = (Dali::Uint16Pair *)jarg1; - { - try { - result = ((Dali::Uint16Pair const *)arg1)->GetWidth(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) { - Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; - uint16_t arg2 ; - - arg1 = (Dali::Uint16Pair *)jarg1; - arg2 = (uint16_t)jarg2; - { - try { - (arg1)->SetHeight(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) { - unsigned short jresult ; - Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; - uint16_t result; - - arg1 = (Dali::Uint16Pair *)jarg1; - { - try { - result = ((Dali::Uint16Pair const *)arg1)->GetHeight(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) { - Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; - uint16_t arg2 ; - - arg1 = (Dali::Uint16Pair *)jarg1; - arg2 = (uint16_t)jarg2; - { - try { - (arg1)->SetX(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) { - unsigned short jresult ; - Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; - uint16_t result; - - arg1 = (Dali::Uint16Pair *)jarg1; - { - try { - result = ((Dali::Uint16Pair const *)arg1)->GetX(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) { - Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; - uint16_t arg2 ; - - arg1 = (Dali::Uint16Pair *)jarg1; - arg2 = (uint16_t)jarg2; - { - try { - (arg1)->SetY(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) { - unsigned short jresult ; - Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; - uint16_t result; - - arg1 = (Dali::Uint16Pair *)jarg1; - { - try { - result = ((Dali::Uint16Pair const *)arg1)->GetY(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; - Dali::Uint16Pair *arg2 = 0 ; - Dali::Uint16Pair *result = 0 ; - - arg1 = (Dali::Uint16Pair *)jarg1; - arg2 = (Dali::Uint16Pair *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; - Dali::Uint16Pair *arg2 = 0 ; - bool result; - - arg1 = (Dali::Uint16Pair *)jarg1; - arg2 = (Dali::Uint16Pair *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; - Dali::Uint16Pair *arg2 = 0 ; - bool result; - - arg1 = (Dali::Uint16Pair *)jarg1; - arg2 = (Dali::Uint16Pair *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; - Dali::Uint16Pair *arg2 = 0 ; - bool result; - - arg1 = (Dali::Uint16Pair *)jarg1; - arg2 = (Dali::Uint16Pair *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; - Dali::Uint16Pair *arg2 = 0 ; - bool result; - - arg1 = (Dali::Uint16Pair *)jarg1; - arg2 = (Dali::Uint16Pair *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) { - Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ; - - arg1 = (Dali::Uint16Pair *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Int32Pair__SWIG_0() { - void * jresult ; - Dali::Int32Pair *result = 0 ; - - { - try { - result = (Dali::Int32Pair *)new Dali::Int32Pair(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Int32Pair__SWIG_1(int32_t x, int32_t y) { - void * jresult ; - Dali::Int32Pair *result = 0 ; - - { - try { - result = (Dali::Int32Pair *)new Dali::Int32Pair(x,y); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Int32Pair_SetX(void * int32Pair, int32_t x) { - Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ; - - { - try { - (pInt32Pair)->SetX(x); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Int32Pair_GetX(void * int32Pair) { - int result ; - Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair); - - { - try { - result = ((Dali::Int32Pair const *)pInt32Pair)->GetX(); - } CALL_CATCH_EXCEPTION(0); - } - - return result; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Int32Pair_SetY(void * int32Pair, int32_t y) { - Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ; - - { - try { - (pInt32Pair)->SetY(y); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Int32Pair_GetY(void * int32Pair) { - Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ; - int result; - - { - try { - result = ((Dali::Int32Pair const *)pInt32Pair)->GetY(); - } CALL_CATCH_EXCEPTION(0); - } - - return result; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Int32Pair(void * int32Pair) { - Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ; - - { - try { - delete pInt32Pair; - } CALL_CATCH_EXCEPTION(); - } - -} - - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() { - void * jresult ; - Dali::Degree *result = 0 ; - - { - try { - result = (Dali::Degree *)new Dali::Degree(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) { - void * jresult ; - float arg1 ; - Dali::Degree *result = 0 ; - - arg1 = (float)jarg1; - { - try { - result = (Dali::Degree *)new Dali::Degree(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) { - void * jresult ; - Dali::Radian arg1 ; - Dali::Radian *argp1 ; - Dali::Degree *result = 0 ; - - argp1 = (Dali::Radian *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg1 = *argp1; - { - try { - result = (Dali::Degree *)new Dali::Degree(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) { - Dali::Degree *arg1 = (Dali::Degree *) 0 ; - float arg2 ; - - arg1 = (Dali::Degree *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->degree = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) { - float jresult ; - Dali::Degree *arg1 = (Dali::Degree *) 0 ; - float result; - - arg1 = (Dali::Degree *)jarg1; - result = (float) ((arg1)->degree); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) { - Dali::Degree *arg1 = (Dali::Degree *) 0 ; - - arg1 = (Dali::Degree *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() { - void * jresult ; - Dali::Radian *result = 0 ; - - result = (Dali::Radian *)&Dali::ANGLE_360; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() { - void * jresult ; - Dali::Radian *result = 0 ; - - result = (Dali::Radian *)&Dali::ANGLE_315; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() { - void * jresult ; - Dali::Radian *result = 0 ; - - result = (Dali::Radian *)&Dali::ANGLE_270; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() { - void * jresult ; - Dali::Radian *result = 0 ; - - result = (Dali::Radian *)&Dali::ANGLE_225; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() { - void * jresult ; - Dali::Radian *result = 0 ; - - result = (Dali::Radian *)&Dali::ANGLE_180; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() { - void * jresult ; - Dali::Radian *result = 0 ; - - result = (Dali::Radian *)&Dali::ANGLE_135; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() { - void * jresult ; - Dali::Radian *result = 0 ; - - result = (Dali::Radian *)&Dali::ANGLE_120; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() { - void * jresult ; - Dali::Radian *result = 0 ; - - result = (Dali::Radian *)&Dali::ANGLE_90; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() { - void * jresult ; - Dali::Radian *result = 0 ; - - result = (Dali::Radian *)&Dali::ANGLE_60; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() { - void * jresult ; - Dali::Radian *result = 0 ; - - result = (Dali::Radian *)&Dali::ANGLE_45; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() { - void * jresult ; - Dali::Radian *result = 0 ; - - result = (Dali::Radian *)&Dali::ANGLE_30; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() { - void * jresult ; - Dali::Radian *result = 0 ; - - result = (Dali::Radian *)&Dali::ANGLE_0; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Degree *arg1 = 0 ; - Dali::Degree *arg2 = 0 ; - bool result; - - arg1 = (Dali::Degree *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0); - return 0; - } - arg2 = (Dali::Degree *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0); - return 0; - } - { - try { - result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Degree *arg1 = 0 ; - Dali::Degree *arg2 = 0 ; - bool result; - - arg1 = (Dali::Degree *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0); - return 0; - } - arg2 = (Dali::Degree *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0); - return 0; - } - { - try { - result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) { - void * jresult ; - Dali::Degree arg1 ; - float arg2 ; - float arg3 ; - Dali::Degree *argp1 ; - Dali::Degree result; - - argp1 = (Dali::Degree *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); - return 0; - } - arg1 = *argp1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - { - try { - result = Dali::Clamp(arg1,arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Degree((const Dali::Degree &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() { - void * jresult ; - Dali::Radian *result = 0 ; - - { - try { - result = (Dali::Radian *)new Dali::Radian(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) { - void * jresult ; - float arg1 ; - Dali::Radian *result = 0 ; - - arg1 = (float)jarg1; - { - try { - result = (Dali::Radian *)new Dali::Radian(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) { - void * jresult ; - Dali::Degree arg1 ; - Dali::Degree *argp1 ; - Dali::Radian *result = 0 ; - - argp1 = (Dali::Degree *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); - return 0; - } - arg1 = *argp1; - { - try { - result = (Dali::Radian *)new Dali::Radian(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) { - void * jresult ; - Dali::Radian *arg1 = (Dali::Radian *) 0 ; - float arg2 ; - Dali::Radian *result = 0 ; - - arg1 = (Dali::Radian *)jarg1; - arg2 = (float)jarg2; - { - try { - result = (Dali::Radian *) &(arg1)->operator =(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Radian *arg1 = (Dali::Radian *) 0 ; - Dali::Degree arg2 ; - Dali::Degree *argp2 ; - Dali::Radian *result = 0 ; - - arg1 = (Dali::Radian *)jarg1; - argp2 = (Dali::Degree *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (Dali::Radian *) &(arg1)->operator =(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) { - float jresult ; - Dali::Radian *arg1 = (Dali::Radian *) 0 ; - float result; - - arg1 = (Dali::Radian *)jarg1; - { - try { - result = (float)((Dali::Radian const *)arg1)->operator float(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) { - Dali::Radian *arg1 = (Dali::Radian *) 0 ; - float arg2 ; - - arg1 = (Dali::Radian *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->radian = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) { - float jresult ; - Dali::Radian *arg1 = (Dali::Radian *) 0 ; - float result; - - arg1 = (Dali::Radian *)jarg1; - result = (float) ((arg1)->radian); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) { - Dali::Radian *arg1 = (Dali::Radian *) 0 ; - - arg1 = (Dali::Radian *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Radian arg1 ; - Dali::Radian arg2 ; - Dali::Radian *argp1 ; - Dali::Radian *argp2 ; - bool result; - - argp1 = (Dali::Radian *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg1 = *argp1; - argp2 = (Dali::Radian *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (bool)Dali::operator ==(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Radian arg1 ; - Dali::Radian arg2 ; - Dali::Radian *argp1 ; - Dali::Radian *argp2 ; - bool result; - - argp1 = (Dali::Radian *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg1 = *argp1; - argp2 = (Dali::Radian *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (bool)Dali::operator !=(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Radian arg1 ; - Dali::Degree arg2 ; - Dali::Radian *argp1 ; - Dali::Degree *argp2 ; - bool result; - - argp1 = (Dali::Radian *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg1 = *argp1; - argp2 = (Dali::Degree *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (bool)Dali::operator ==(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Radian arg1 ; - Dali::Degree arg2 ; - Dali::Radian *argp1 ; - Dali::Degree *argp2 ; - bool result; - - argp1 = (Dali::Radian *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg1 = *argp1; - argp2 = (Dali::Degree *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (bool)Dali::operator !=(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Degree arg1 ; - Dali::Radian arg2 ; - Dali::Degree *argp1 ; - Dali::Radian *argp2 ; - bool result; - - argp1 = (Dali::Degree *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); - return 0; - } - arg1 = *argp1; - argp2 = (Dali::Radian *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (bool)Dali::operator ==(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Degree arg1 ; - Dali::Radian arg2 ; - Dali::Degree *argp1 ; - Dali::Radian *argp2 ; - bool result; - - argp1 = (Dali::Degree *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); - return 0; - } - arg1 = *argp1; - argp2 = (Dali::Radian *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (bool)Dali::operator !=(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Radian arg1 ; - Dali::Radian arg2 ; - Dali::Radian *argp1 ; - Dali::Radian *argp2 ; - bool result; - - argp1 = (Dali::Radian *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg1 = *argp1; - argp2 = (Dali::Radian *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (bool)Dali::operator >(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Radian arg1 ; - Dali::Degree arg2 ; - Dali::Radian *argp1 ; - Dali::Degree *argp2 ; - bool result; - - argp1 = (Dali::Radian *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg1 = *argp1; - argp2 = (Dali::Degree *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (bool)Dali::operator >(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Degree arg1 ; - Dali::Radian arg2 ; - Dali::Degree *argp1 ; - Dali::Radian *argp2 ; - bool result; - - argp1 = (Dali::Degree *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); - return 0; - } - arg1 = *argp1; - argp2 = (Dali::Radian *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (bool)Dali::operator >(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Radian arg1 ; - Dali::Radian arg2 ; - Dali::Radian *argp1 ; - Dali::Radian *argp2 ; - bool result; - - argp1 = (Dali::Radian *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg1 = *argp1; - argp2 = (Dali::Radian *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (bool)Dali::operator <(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Radian arg1 ; - Dali::Degree arg2 ; - Dali::Radian *argp1 ; - Dali::Degree *argp2 ; - bool result; - - argp1 = (Dali::Radian *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg1 = *argp1; - argp2 = (Dali::Degree *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (bool)Dali::operator <(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Degree arg1 ; - Dali::Radian arg2 ; - Dali::Degree *argp1 ; - Dali::Radian *argp2 ; - bool result; - - argp1 = (Dali::Degree *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0); - return 0; - } - arg1 = *argp1; - argp2 = (Dali::Radian *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (bool)Dali::operator <(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) { - void * jresult ; - Dali::Radian arg1 ; - float arg2 ; - Dali::Radian *argp1 ; - Dali::Radian result; - - argp1 = (Dali::Radian *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg1 = *argp1; - arg2 = (float)jarg2; - { - try { - result = Dali::operator *(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Radian((const Dali::Radian &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) { - void * jresult ; - Dali::Radian arg1 ; - Dali::Radian *argp1 ; - Dali::Radian result; - - argp1 = (Dali::Radian *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg1 = *argp1; - { - try { - result = Dali::operator -(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Radian((const Dali::Radian &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) { - void * jresult ; - Dali::Radian arg1 ; - float arg2 ; - float arg3 ; - Dali::Radian *argp1 ; - Dali::Radian result; - - argp1 = (Dali::Radian *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg1 = *argp1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - { - try { - result = Dali::Clamp(arg1,arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Radian((const Dali::Radian &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() { - void * jresult ; - Dali::Matrix *result = 0 ; - - { - try { - result = (Dali::Matrix *)new Dali::Matrix(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(bool jarg1) { - void * jresult ; - bool arg1 ; - Dali::Matrix *result = 0 ; - - arg1 = jarg1 ? true : false; - { - try { - result = (Dali::Matrix *)new Dali::Matrix(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) { - void * jresult ; - float *arg1 = (float *) 0 ; - Dali::Matrix *result = 0 ; - - arg1 = jarg1; - { - try { - result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) { - void * jresult ; - Dali::Quaternion *arg1 = 0 ; - Dali::Matrix *result = 0 ; - - arg1 = (Dali::Quaternion *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) { - void * jresult ; - Dali::Matrix *arg1 = 0 ; - Dali::Matrix *result = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Matrix *arg2 = 0 ; - Dali::Matrix *result = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - arg2 = (Dali::Matrix *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() { - void * jresult ; - Dali::Matrix *result = 0 ; - - result = (Dali::Matrix *)&Dali::Matrix::IDENTITY; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) { - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - - arg1 = (Dali::Matrix *)jarg1; - { - try { - (arg1)->SetIdentity(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) { - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Vector3 *arg2 = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) { - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Matrix *arg2 = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - arg2 = (Dali::Matrix *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0); - return ; - } - { - try { - ((Dali::Matrix const *)arg1)->InvertTransform(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) { - bool jresult ; - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - bool result; - - arg1 = (Dali::Matrix *)jarg1; - { - try { - result = (bool)(arg1)->Invert(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) { - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - - arg1 = (Dali::Matrix *)jarg1; - { - try { - (arg1)->Transpose(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) { - void * jresult ; - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Vector3 result; - - arg1 = (Dali::Matrix *)jarg1; - { - try { - result = ((Dali::Matrix const *)arg1)->GetXAxis(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) { - void * jresult ; - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Vector3 result; - - arg1 = (Dali::Matrix *)jarg1; - { - try { - result = ((Dali::Matrix const *)arg1)->GetYAxis(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) { - void * jresult ; - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Vector3 result; - - arg1 = (Dali::Matrix *)jarg1; - { - try { - result = ((Dali::Matrix const *)arg1)->GetZAxis(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) { - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Vector3 *arg2 = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetXAxis((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) { - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Vector3 *arg2 = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetYAxis((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) { - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Vector3 *arg2 = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetZAxis((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) { - void * jresult ; - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Vector4 *result = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - { - try { - result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) { - void * jresult ; - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Vector3 *result = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - { - try { - result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) { - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Vector4 *arg2 = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetTranslation((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) { - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Vector3 *arg2 = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetTranslation((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) { - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - - arg1 = (Dali::Matrix *)jarg1; - { - try { - (arg1)->OrthoNormalize(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) { - void * jresult ; - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - float *result = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - { - try { - result = (float *)((Dali::Matrix const *)arg1)->AsFloat(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { - Dali::Matrix *arg1 = 0 ; - Dali::Matrix *arg2 = 0 ; - Dali::Matrix *arg3 = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0); - return ; - } - arg2 = (Dali::Matrix *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); - return ; - } - arg3 = (Dali::Matrix *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); - return ; - } - { - try { - Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) { - Dali::Matrix *arg1 = 0 ; - Dali::Matrix *arg2 = 0 ; - Dali::Quaternion *arg3 = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0); - return ; - } - arg2 = (Dali::Matrix *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); - return ; - } - arg3 = (Dali::Quaternion *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return ; - } - { - try { - Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Vector4 *arg2 = 0 ; - Dali::Vector4 result; - - arg1 = (Dali::Matrix *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); - return 0; - } - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_3(void * nuiMatrixLhs, void * nuiMatrixRhs) { - void * jresult ; - Dali::Matrix *lhsPtr = (Dali::Matrix *) 0 ; - Dali::Matrix *rhsPtr = (Dali::Matrix *) 0 ; - Dali::Matrix result(false); - - lhsPtr = (Dali::Matrix *)nuiMatrixLhs; - if (!lhsPtr) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0); - return 0; - } - rhsPtr = (Dali::Matrix *)nuiMatrixRhs; - if (!rhsPtr) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0); - return 0; - } - { - try { - result = ((Dali::Matrix const *)lhsPtr)->operator *((Dali::Matrix const &)*rhsPtr); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Matrix((const Dali::Matrix &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_4(void * nuiMatrixLhs, void * nuiMatrixRhs) { - // Faster mulitply operation without memcpy - - Dali::Matrix *jresult = (Dali::Matrix *)0; - Dali::Matrix *lhsPtr = (Dali::Matrix *)0; - Dali::Matrix *rhsPtr = (Dali::Matrix *)0; - - lhsPtr = (Dali::Matrix *)nuiMatrixLhs; - if (!lhsPtr) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0); - return 0; - } - rhsPtr = (Dali::Matrix *)nuiMatrixRhs; - if (!rhsPtr) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0); - return 0; - } - { - try { - jresult = new Dali::Matrix(false); - Dali::Matrix::Multiply((Dali::Matrix &)*jresult,(Dali::Matrix const &)*rhsPtr,(Dali::Matrix const &)*lhsPtr); - } CALL_CATCH_EXCEPTION(0); - } - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_MultiplyAssign(void * nuiMatrix, void * nuiMatrixRhs) { - void * jresult = 0; - Dali::Matrix *lhsPtr = (Dali::Matrix *) 0 ; - Dali::Matrix *rhsPtr = (Dali::Matrix *) 0 ; - Dali::Matrix *retPtr = (Dali::Matrix *) 0 ; - - lhsPtr = (Dali::Matrix *)nuiMatrix; - if (!lhsPtr) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0); - return 0; - } - rhsPtr = (Dali::Matrix *)nuiMatrixRhs; - if (!rhsPtr) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0); - return 0; - } - { - try { - retPtr = (Dali::Matrix *) &(lhsPtr)->operator *=((Dali::Matrix const &)*rhsPtr); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)retPtr; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Matrix *arg2 = 0 ; - bool result; - - arg1 = (Dali::Matrix *)jarg1; - arg2 = (Dali::Matrix *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Matrix *arg2 = 0 ; - bool result; - - arg1 = (Dali::Matrix *)jarg1; - arg2 = (Dali::Matrix *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix_ValueOfIndex__SWIG_0(void * nuiMatrix, unsigned int index) { - float jresult ; - Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ; - - pMatrix = (Dali::Matrix *)nuiMatrix; - if (!pMatrix) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); - return 0; - } - if (index >= 16) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 16.)", 0); - return 0; - } - { - try { - const float* temp = ((Dali::Matrix const *)pMatrix)->AsFloat(); - jresult = temp[index]; - } CALL_CATCH_EXCEPTION(0); - } - return jresult; -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix_ValueOfIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn) { - float jresult ; - Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ; - - pMatrix = (Dali::Matrix *)nuiMatrix; - if (!pMatrix) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); - return 0; - } - if (indexRow >= 4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 4.)", 0); - return 0; - } - if (indexColumn >= 4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 4.)", 0); - return 0; - } - { - try { - const float* temp = ((Dali::Matrix const *)pMatrix)->AsFloat(); - jresult = temp[(indexColumn << 2) | indexRow]; - } CALL_CATCH_EXCEPTION(0); - } - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetValueAtIndex__SWIG_0(void * nuiMatrix, unsigned int index, float value) { - Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ; - - pMatrix = (Dali::Matrix *)nuiMatrix; - if (!pMatrix) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); - return; - } - if (index >= 16) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 16.)", 0); - return; - } - { - try { - float* temp = ((Dali::Matrix *)pMatrix)->AsFloat(); - temp[index] = value; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetValueAtIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn, float value) { - Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ; - - pMatrix = (Dali::Matrix *)nuiMatrix; - if (!pMatrix) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); - return; - } - if (indexRow >= 4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 4.)", 0); - return; - } - if (indexColumn >= 4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 4.)", 0); - return; - } - { - try { - float* temp = ((Dali::Matrix *)pMatrix)->AsFloat(); - temp[(indexColumn << 2) | indexRow] = value; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Quaternion *arg3 = 0 ; - Dali::Vector3 *arg4 = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - arg3 = (Dali::Quaternion *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return ; - } - arg4 = (Dali::Vector3 *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Quaternion *arg3 = 0 ; - Dali::Vector3 *arg4 = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - arg3 = (Dali::Quaternion *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return ; - } - arg4 = (Dali::Vector3 *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) { - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Vector3 *arg3 = 0 ; - Dali::Vector3 *arg4 = 0 ; - Dali::Vector3 *arg5 = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - arg3 = (Dali::Vector3 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - arg4 = (Dali::Vector3 *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - arg5 = (Dali::Vector3 *)jarg5; - if (!arg5) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Quaternion *arg3 = 0 ; - Dali::Vector3 *arg4 = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); - return ; - } - arg3 = (Dali::Quaternion *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0); - return ; - } - arg4 = (Dali::Vector3 *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); - return ; - } - { - try { - ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) { - Dali::Matrix *arg1 = (Dali::Matrix *) 0 ; - - arg1 = (Dali::Matrix *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() { - void * jresult ; - Dali::Matrix3 *result = 0 ; - - result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() { - void * jresult ; - Dali::Matrix3 *result = 0 ; - - { - try { - result = (Dali::Matrix3 *)new Dali::Matrix3(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Matrix3 *arg1 = 0 ; - Dali::Matrix3 *result = 0 ; - - arg1 = (Dali::Matrix3 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) { - void * jresult ; - Dali::Matrix *arg1 = 0 ; - Dali::Matrix3 *result = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) { - void * jresult ; - float arg1 ; - float arg2 ; - float arg3 ; - float arg4 ; - float arg5 ; - float arg6 ; - float arg7 ; - float arg8 ; - float arg9 ; - Dali::Matrix3 *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - arg5 = (float)jarg5; - arg6 = (float)jarg6; - arg7 = (float)jarg7; - arg8 = (float)jarg8; - arg9 = (float)jarg9; - { - try { - result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; - Dali::Matrix3 *arg2 = 0 ; - Dali::Matrix3 *result = 0 ; - - arg1 = (Dali::Matrix3 *)jarg1; - arg2 = (Dali::Matrix3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; - Dali::Matrix *arg2 = 0 ; - Dali::Matrix3 *result = 0 ; - - arg1 = (Dali::Matrix3 *)jarg1; - arg2 = (Dali::Matrix *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; - Dali::Matrix3 *arg2 = 0 ; - bool result; - - arg1 = (Dali::Matrix3 *)jarg1; - arg2 = (Dali::Matrix3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; - Dali::Matrix3 *arg2 = 0 ; - bool result; - - arg1 = (Dali::Matrix3 *)jarg1; - arg2 = (Dali::Matrix3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_ValueOfIndex__SWIG_0(void * nuiMatrix, unsigned int index) { - float jresult ; - Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ; - - pMatrix = (Dali::Matrix3 *)nuiMatrix; - if (!pMatrix) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); - return 0; - } - if (index >= 9) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 9.)", 0); - return 0; - } - { - try { - const float* temp = ((Dali::Matrix3 const *)pMatrix)->AsFloat(); - jresult = temp[index]; - } CALL_CATCH_EXCEPTION(0); - } - return jresult; -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_ValueOfIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn) { - float jresult ; - Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ; - - pMatrix = (Dali::Matrix3 *)nuiMatrix; - if (!pMatrix) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); - return 0; - } - if (indexRow >= 3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 3.)", 0); - return 0; - } - if (indexColumn >= 3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 3.)", 0); - return 0; - } - { - try { - const float* temp = ((Dali::Matrix3 const *)pMatrix)->AsFloat(); - jresult = temp[indexColumn * 3 + indexRow]; - } CALL_CATCH_EXCEPTION(0); - } - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetValueAtIndex__SWIG_0(void * nuiMatrix, unsigned int index, float value) { - Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ; - - pMatrix = (Dali::Matrix3 *)nuiMatrix; - if (!pMatrix) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); - return; - } - if (index >= 9) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 9.)", 0); - return; - } - { - try { - float* temp = ((Dali::Matrix3 *)pMatrix)->AsFloat(); - temp[index] = value; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetValueAtIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn, float value) { - Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ; - - pMatrix = (Dali::Matrix3 *)nuiMatrix; - if (!pMatrix) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); - return; - } - if (indexRow >= 3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 3.)", 0); - return; - } - if (indexColumn >= 3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 3.)", 0); - return; - } - { - try { - float* temp = ((Dali::Matrix3 *)pMatrix)->AsFloat(); - temp[indexColumn * 3 + indexRow] = value; - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) { - Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; - - arg1 = (Dali::Matrix3 *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) { - Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; - - arg1 = (Dali::Matrix3 *)jarg1; - { - try { - (arg1)->SetIdentity(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) { - void * jresult ; - Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; - float *result = 0 ; - - arg1 = (Dali::Matrix3 *)jarg1; - { - try { - result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) { - bool jresult ; - Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; - bool result; - - arg1 = (Dali::Matrix3 *)jarg1; - { - try { - result = (bool)(arg1)->Invert(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) { - bool jresult ; - Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; - bool result; - - arg1 = (Dali::Matrix3 *)jarg1; - { - try { - result = (bool)(arg1)->Transpose(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) { - Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; - float arg2 ; - - arg1 = (Dali::Matrix3 *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->Scale(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) { - float jresult ; - Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; - float result; - - arg1 = (Dali::Matrix3 *)jarg1; - { - try { - result = (float)((Dali::Matrix3 const *)arg1)->Magnitude(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) { - bool jresult ; - Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ; - bool result; - - arg1 = (Dali::Matrix3 *)jarg1; - { - try { - result = (bool)(arg1)->ScaledInverseTranspose(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) { - Dali::Matrix3 *arg1 = 0 ; - Dali::Matrix3 *arg2 = 0 ; - Dali::Matrix3 *arg3 = 0 ; - - arg1 = (Dali::Matrix3 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0); - return ; - } - arg2 = (Dali::Matrix3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); - return ; - } - arg3 = (Dali::Matrix3 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); - return ; - } - { - try { - Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_1(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Matrix3 *arg1 = 0 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Vector3 result; - - arg1 = (Dali::Matrix3 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); - return 0; - } - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = ((Dali::Matrix3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_2(void * nuiMatrix3Lhs, void * nuiMatrix3Rhs) { - void * jresult ; - Dali::Matrix3 *lhsPtr = 0 ; - Dali::Matrix3 *rhsPtr = 0 ; - Dali::Matrix3 result; - - lhsPtr = (Dali::Matrix3 *)nuiMatrix3Lhs; - if (!lhsPtr) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0); - return 0; - } - rhsPtr = (Dali::Matrix3 *)nuiMatrix3Rhs; - if (!rhsPtr) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0); - return 0; - } - { - try { - result = ((Dali::Matrix3 const *)lhsPtr)->operator *((Dali::Matrix3 const &)*rhsPtr); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Matrix3((const Dali::Matrix3 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_3(void * nuiMatrix3Lhs, void * nuiMatrix3Rhs) { - // Faster mulitply operation without memcpy - - Dali::Matrix3 *jresult = 0; - Dali::Matrix3 *lhsPtr = 0; - Dali::Matrix3 *rhsPtr = 0; - - lhsPtr = (Dali::Matrix3 *)nuiMatrix3Lhs; - if (!lhsPtr) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0); - return 0; - } - rhsPtr = (Dali::Matrix3 *)nuiMatrix3Rhs; - if (!rhsPtr) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0); - return 0; - } - { - try { - jresult = new Dali::Matrix3(); - Dali::Matrix3::Multiply((Dali::Matrix3 &)*jresult,(Dali::Matrix3 const &)*rhsPtr,(Dali::Matrix3 const &)*lhsPtr); - } CALL_CATCH_EXCEPTION(0); - } - - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_MultiplyAssign(void * nuiMatrix, void * nuiMatrixRhs) { - void * jresult = 0; - Dali::Matrix3 *lhsPtr = (Dali::Matrix3 *) 0 ; - Dali::Matrix3 *rhsPtr = (Dali::Matrix3 *) 0 ; - Dali::Matrix3 *retPtr = (Dali::Matrix3 *) 0 ; - - lhsPtr = (Dali::Matrix3 *)nuiMatrix; - if (!lhsPtr) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0); - return 0; - } - rhsPtr = (Dali::Matrix3 *)nuiMatrixRhs; - if (!rhsPtr) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0); - return 0; - } - { - try { - retPtr = (Dali::Matrix3 *) &(lhsPtr)->operator *=((Dali::Matrix3 const &)*rhsPtr); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)retPtr; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) { - float jresult ; - float arg1 ; - float arg2 ; - float result; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - { - try { - result = (float)Dali::Random::Range(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() { - void * jresult ; - Dali::Vector4 result; - - { - try { - result = Dali::Random::Axis(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() { - void * jresult ; - Dali::AngleAxis *result = 0 ; - - { - try { - result = (Dali::AngleAxis *)new Dali::AngleAxis(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Radian arg1 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Radian *argp1 ; - Dali::AngleAxis *result = 0 ; - - argp1 = (Dali::Radian *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg1 = *argp1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) { - Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ; - Dali::Radian *arg2 = (Dali::Radian *) 0 ; - - arg1 = (Dali::AngleAxis *)jarg1; - arg2 = (Dali::Radian *)jarg2; - if (arg1) (arg1)->angle = *arg2; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) { - void * jresult ; - Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ; - Dali::Radian *result = 0 ; - - arg1 = (Dali::AngleAxis *)jarg1; - result = (Dali::Radian *)& ((arg1)->angle); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) { - Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ; - Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ; - - arg1 = (Dali::AngleAxis *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (arg1) (arg1)->axis = *arg2; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) { - void * jresult ; - Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ; - Dali::Vector3 *result = 0 ; - - arg1 = (Dali::AngleAxis *)jarg1; - result = (Dali::Vector3 *)& ((arg1)->axis); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) { - Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ; - - arg1 = (Dali::AngleAxis *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) { - bool jresult ; - Dali::AngleAxis *arg1 = 0 ; - Dali::AngleAxis *arg2 = 0 ; - bool result; - - arg1 = (Dali::AngleAxis *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0); - return 0; - } - arg2 = (Dali::AngleAxis *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0); - return 0; - } - { - try { - result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) { - unsigned int jresult ; - unsigned int arg1 ; - unsigned int result; - - arg1 = (unsigned int)jarg1; - { - try { - result = (unsigned int)Dali::NextPowerOfTwo(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) { - bool jresult ; - unsigned int arg1 ; - bool result; - - arg1 = (unsigned int)jarg1; - { - try { - result = (bool)Dali::IsPowerOfTwo(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) { - float jresult ; - float arg1 ; - float arg2 ; - float result; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - { - try { - result = (float)Dali::GetRangedEpsilon(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) { - bool jresult ; - float arg1 ; - bool result; - - arg1 = (float)jarg1; - { - try { - result = (bool)Dali::EqualsZero(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) { - bool jresult ; - float arg1 ; - float arg2 ; - bool result; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - { - try { - result = (bool)Dali::Equals(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) { - bool jresult ; - float arg1 ; - float arg2 ; - float arg3 ; - bool result; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - { - try { - result = (bool)Dali::Equals(arg1,arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) { - float jresult ; - float arg1 ; - int arg2 ; - float result; - - arg1 = (float)jarg1; - arg2 = (int)jarg2; - { - try { - result = (float)Dali::Round(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) { - float jresult ; - float arg1 ; - float arg2 ; - float arg3 ; - float result; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - { - try { - result = (float)Dali::WrapInDomain(arg1,arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) { - float jresult ; - float arg1 ; - float arg2 ; - float arg3 ; - float arg4 ; - float result; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - { - try { - result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() { - int jresult ; - int result; - - result = (int)(int)Dali::Property::INVALID_INDEX; - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() { - int jresult ; - int result; - - result = (int)(int)Dali::Property::INVALID_KEY; - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() { - int jresult ; - int result; - - result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX; - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) { - void * jresult ; - Dali::Handle *arg1 = 0 ; - Dali::Property::Index arg2 ; - Dali::Property *result = 0 ; - - arg1 = (Dali::Handle *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); - return 0; - } - arg2 = (Dali::Property::Index)jarg2; - { - try { - result = (Dali::Property *)new Dali::Property(*arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) { - void * jresult ; - Dali::Handle *arg1 = 0 ; - Dali::Property::Index arg2 ; - int arg3 ; - Dali::Property *result = 0 ; - - arg1 = (Dali::Handle *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); - return 0; - } - arg2 = (Dali::Property::Index)jarg2; - arg3 = (int)jarg3; - { - try { - result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) { - void * jresult ; - Dali::Handle *arg1 = 0 ; - std::string *arg2 = 0 ; - Dali::Property *result = 0 ; - - arg1 = (Dali::Handle *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); - return 0; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) { - void * jresult ; - Dali::Handle *arg1 = 0 ; - std::string *arg2 = 0 ; - int arg3 ; - Dali::Property *result = 0 ; - - arg1 = (Dali::Handle *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); - return 0; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (int)jarg3; - { - try { - result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) { - Dali::Property *arg1 = (Dali::Property *) 0 ; - - arg1 = (Dali::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) { - Dali::Property *arg1 = (Dali::Property *) 0 ; - Dali::Handle *arg2 = 0 ; - - arg1 = (Dali::Property *)jarg1; - arg2 = (Dali::Handle *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); - return ; - } - if (arg1) (arg1)->object = *arg2; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) { - void * jresult ; - Dali::Property *arg1 = (Dali::Property *) 0 ; - Dali::Handle *result = 0 ; - - arg1 = (Dali::Property *)jarg1; - result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) { - Dali::Property *arg1 = (Dali::Property *) 0 ; - Dali::Property::Index arg2 ; - - arg1 = (Dali::Property *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - if (arg1) (arg1)->propertyIndex = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) { - int jresult ; - Dali::Property *arg1 = (Dali::Property *) 0 ; - Dali::Property::Index result; - - arg1 = (Dali::Property *)jarg1; - result = (Dali::Property::Index) ((arg1)->propertyIndex); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) { - Dali::Property *arg1 = (Dali::Property *) 0 ; - int arg2 ; - - arg1 = (Dali::Property *)jarg1; - arg2 = (int)jarg2; - if (arg1) (arg1)->componentIndex = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) { - int jresult ; - Dali::Property *arg1 = (Dali::Property *) 0 ; - int result; - - arg1 = (Dali::Property *)jarg1; - result = (int) ((arg1)->componentIndex); - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() { - void * jresult ; - Dali::Property::Array *result = 0 ; - - { - try { - result = (Dali::Property::Array *)new Dali::Property::Array(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Property::Array *arg1 = 0 ; - Dali::Property::Array *result = 0 ; - - arg1 = (Dali::Property::Array *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) { - Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; - - arg1 = (Dali::Property::Array *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) { - unsigned long jresult ; - Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; - Dali::Property::Array::SizeType result; - - arg1 = (Dali::Property::Array *)jarg1; - { - try { - result = ((Dali::Property::Array const *)arg1)->Size(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) { - unsigned long jresult ; - Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; - Dali::Property::Array::SizeType result; - - arg1 = (Dali::Property::Array *)jarg1; - { - try { - result = ((Dali::Property::Array const *)arg1)->Count(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) { - bool jresult ; - Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; - bool result; - - arg1 = (Dali::Property::Array *)jarg1; - { - try { - result = (bool)((Dali::Property::Array const *)arg1)->Empty(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) { - Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; - - arg1 = (Dali::Property::Array *)jarg1; - { - try { - (arg1)->Clear(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) { - Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; - Dali::Property::Array::SizeType arg2 ; - - arg1 = (Dali::Property::Array *)jarg1; - arg2 = (Dali::Property::Array::SizeType)jarg2; - { - try { - (arg1)->Reserve(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) { - Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; - Dali::Property::Array::SizeType arg2 ; - - arg1 = (Dali::Property::Array *)jarg1; - arg2 = (Dali::Property::Array::SizeType)jarg2; - { - try { - (arg1)->Resize(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) { - unsigned long jresult ; - Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; - Dali::Property::Array::SizeType result; - - arg1 = (Dali::Property::Array *)jarg1; - { - try { - result = (arg1)->Capacity(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) { - Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; - Dali::Property::Value *arg2 = 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 ; - } - { - try { - (arg1)->PushBack((Dali::Property::Value const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -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); - } CALL_CATCH_EXCEPTION(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 ; - Dali::Property::Array::SizeType arg2 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Property::Array *)jarg1; - arg2 = (Dali::Property::Array::SizeType)jarg2; - { - try { - result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; - Dali::Property::Array::SizeType arg2 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Property::Array *)jarg1; - arg2 = (Dali::Property::Array::SizeType)jarg2; - { - try { - result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ; - Dali::Property::Array *arg2 = 0 ; - Dali::Property::Array *result = 0 ; - - arg1 = (Dali::Property::Array *)jarg1; - arg2 = (Dali::Property::Array *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) { - Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; - enum Dali::Property::Key::Type arg2 ; - - arg1 = (Dali::Property::Key *)jarg1; - arg2 = (enum Dali::Property::Key::Type)jarg2; - if (arg1) (arg1)->type = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) { - int jresult ; - Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; - enum Dali::Property::Key::Type result; - - arg1 = (Dali::Property::Key *)jarg1; - result = (enum Dali::Property::Key::Type) ((arg1)->type); - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) { - Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; - Dali::Property::Index arg2 ; - - arg1 = (Dali::Property::Key *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - if (arg1) (arg1)->indexKey = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) { - int jresult ; - Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; - Dali::Property::Index result; - - arg1 = (Dali::Property::Key *)jarg1; - result = (Dali::Property::Index) ((arg1)->indexKey); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) { - Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::Property::Key *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - if (arg1) (arg1)->stringKey = *arg2; - - //argout typemap for const std::string& - -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) { - char * jresult ; - Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; - std::string *result = 0 ; - - arg1 = (Dali::Property::Key *)jarg1; - result = (std::string *) & ((arg1)->stringKey); - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::Property::Key *result = 0 ; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - { - try { - result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) { - void * jresult ; - Dali::Property::Index arg1 ; - Dali::Property::Key *result = 0 ; - - arg1 = (Dali::Property::Index)jarg1; - { - try { - result = (Dali::Property::Key *)new Dali::Property::Key(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) { - bool jresult ; - Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; - std::string *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Key *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - result = (bool)(arg1)->operator ==((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) { - bool jresult ; - Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; - Dali::Property::Index arg2 ; - bool result; - - arg1 = (Dali::Property::Key *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - { - try { - result = (bool)(arg1)->operator ==(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; - Dali::Property::Key *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Key *)jarg1; - arg2 = (Dali::Property::Key *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0); - return 0; - } - { - try { - result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) { - bool jresult ; - Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; - std::string *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Key *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - result = (bool)(arg1)->operator !=((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) { - bool jresult ; - Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; - Dali::Property::Index arg2 ; - bool result; - - arg1 = (Dali::Property::Key *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - { - try { - result = (bool)(arg1)->operator !=(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; - Dali::Property::Key *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Key *)jarg1; - arg2 = (Dali::Property::Key *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0); - return 0; - } - { - try { - result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) { - Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ; - - arg1 = (Dali::Property::Key *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() { - void * jresult ; - Dali::Property::Map *result = 0 ; - - { - try { - result = (Dali::Property::Map *)new Dali::Property::Map(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Property::Map *arg1 = 0 ; - Dali::Property::Map *result = 0 ; - - arg1 = (Dali::Property::Map *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) { - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - - arg1 = (Dali::Property::Map *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) { - unsigned long jresult ; - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - Dali::Property::Map::SizeType result; - - arg1 = (Dali::Property::Map *)jarg1; - { - try { - result = ((Dali::Property::Map const *)arg1)->Count(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) { - bool jresult ; - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - bool result; - - arg1 = (Dali::Property::Map *)jarg1; - { - try { - result = (bool)((Dali::Property::Map const *)arg1)->Empty(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) { - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - char *arg2 = (char *) 0 ; - Dali::Property::Value *arg3 = 0 ; - - arg1 = (Dali::Property::Map *)jarg1; - arg2 = (char *)jarg2; - arg3 = (Dali::Property::Value *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); - return ; - } - { - try { - (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) { - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - Dali::Property::Index arg2 ; - Dali::Property::Value *arg3 = 0 ; - - arg1 = (Dali::Property::Map *)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)->Insert(arg2,(Dali::Property::Value const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) { - void * jresult ; - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - char *arg2 = (char *) 0 ; - Dali::Property::Value *arg3 = 0 ; - Dali::Property::Map *result = 0 ; - - arg1 = (Dali::Property::Map *)jarg1; - arg2 = (char *)jarg2; - arg3 = (Dali::Property::Value *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) { - void * jresult ; - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - Dali::Property::Index arg2 ; - Dali::Property::Value *arg3 = 0 ; - Dali::Property::Map *result = 0 ; - - arg1 = (Dali::Property::Map *)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 0; - } - { - try { - result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - Dali::Property::Map::SizeType arg2 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Property::Map *)jarg1; - arg2 = (Dali::Property::Map::SizeType)jarg2; - { - try { - result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) { - char * jresult ; - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - Dali::Property::Map::SizeType arg2 ; - std::string *result = 0 ; - - arg1 = (Dali::Property::Map *)jarg1; - arg2 = (Dali::Property::Map::SizeType)jarg2; - { - try { - result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - Dali::Property::Map::SizeType arg2 ; - SwigValueWrapper< Dali::Property::Key > result; - - arg1 = (Dali::Property::Map *)jarg1; - arg2 = (Dali::Property::Map::SizeType)jarg2; - { - try { - result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Property::Key((const Dali::Property::Key &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - Dali::Property::Map::SizeType arg2 ; - StringValuePair *result = 0 ; - - arg1 = (Dali::Property::Map *)jarg1; - arg2 = (Dali::Property::Map::SizeType)jarg2; - { - try { - result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) { - void * jresult ; - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - char *arg2 = (char *) 0 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Property::Map *)jarg1; - arg2 = (char *)jarg2; - { - try { - result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) { - void * jresult ; - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - Dali::Property::Index arg2 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Property::Map *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - { - try { - result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) { - void * jresult ; - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - Dali::Property::Index arg2 ; - std::string *arg3 = 0 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Property::Map *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - if (!jarg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg3_str(jarg3); - arg3 = &arg3_str; - { - try { - result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) { - void * jresult ; - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - std::string *arg2 = 0 ; - Dali::Property::Type arg3 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Property::Map *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Property::Type)jarg3; - { - try { - result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) { - void * jresult ; - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - Dali::Property::Index arg2 ; - Dali::Property::Type arg3 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Property::Map *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - arg3 = (Dali::Property::Type)jarg3; - { - try { - result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) { - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - - arg1 = (Dali::Property::Map *)jarg1; - { - try { - (arg1)->Clear(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_0(void * map, int key) { - Dali::Property::Map *propertyMap = (Dali::Property::Map *)map; - Dali::Property::Index intKey = (Dali::Property::Index)key; - bool isRemoved = false; - { - try { - isRemoved = propertyMap->Remove(intKey); - } CALL_CATCH_EXCEPTION(0); - } - return isRemoved; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_1(void * map, char * key) { - Dali::Property::Map *propertyMap = (Dali::Property::Map *)map; - std::string strKey(key); - bool isRemoved = false; - { - try { - isRemoved = propertyMap->Remove(strKey); - } CALL_CATCH_EXCEPTION(0); - } - return isRemoved; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) { - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - Dali::Property::Map *arg2 = 0 ; - - arg1 = (Dali::Property::Map *)jarg1; - arg2 = (Dali::Property::Map *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); - return ; - } - { - try { - (arg1)->Merge((Dali::Property::Map const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) { - void * jresult ; - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - std::string *arg2 = 0 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Property::Map *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) { - void * jresult ; - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - Dali::Property::Index arg2 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Property::Map *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - { - try { - result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ; - Dali::Property::Map *arg2 = 0 ; - Dali::Property::Map *result = 0 ; - - arg1 = (Dali::Property::Map *)jarg1; - arg2 = (Dali::Property::Map *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) { - - Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1; - - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return; - } - std::string arg2_str(jarg2); - std::string* arg2 = &arg2_str; - - Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3; - - { - try { - arg1->operator[]((std::string const &)*arg2) = *arg3; - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) { - - Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1; - Dali::Property::Index arg2 = (Dali::Property::Index)jarg2; - Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3; - - { - try { - arg1->operator[](arg2) = *arg3; - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() { - void * jresult ; - Dali::Property::Value *result = 0 ; - - { - try { - result = (Dali::Property::Value *)new Dali::Property::Value(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(bool jarg1) { - void * jresult ; - bool arg1 ; - Dali::Property::Value *result = 0 ; - - arg1 = jarg1 ? true : false; - { - try { - result = (Dali::Property::Value *)new Dali::Property::Value(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) { - void * jresult ; - int arg1 ; - Dali::Property::Value *result = 0 ; - - arg1 = (int)jarg1; - { - try { - result = (Dali::Property::Value *)new Dali::Property::Value(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) { - void * jresult ; - float arg1 ; - Dali::Property::Value *result = 0 ; - - arg1 = (float)jarg1; - { - try { - result = (Dali::Property::Value *)new Dali::Property::Value(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) { - void * jresult ; - Dali::Vector2 *arg1 = 0 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Vector2 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) { - void * jresult ; - Dali::Vector3 *arg1 = 0 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) { - void * jresult ; - Dali::Vector4 *arg1 = 0 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Vector4 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) { - void * jresult ; - Dali::Matrix3 *arg1 = 0 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Matrix3 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) { - void * jresult ; - Dali::Matrix *arg1 = 0 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Matrix *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) { - void * jresult ; - Dali::Rect< int > *arg1 = 0 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Rect< int > *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) { - void * jresult ; - Dali::AngleAxis *arg1 = 0 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::AngleAxis *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) { - void * jresult ; - Dali::Quaternion *arg1 = 0 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Quaternion *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::Property::Value *result = 0 ; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - { - try { - result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) { - void * jresult ; - Dali::Property::Array *arg1 = 0 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Property::Array *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0); - return 0; - } - { - try { - result = (Dali::Property::Value *)new Dali::Property::Value(*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) { - void * jresult ; - Dali::Property::Map *arg1 = 0 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Property::Map *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0); - return 0; - } - { - try { - result = (Dali::Property::Value *)new Dali::Property::Value(*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) { - void * jresult ; - Extents *arg1 = 0 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Extents *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*) result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) { - void * jresult ; - Dali::Property::Type arg1 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Property::Type)jarg1; - { - try { - result = (Dali::Property::Value *)new Dali::Property::Value(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) { - void * jresult ; - Dali::Property::Value *arg1 = 0 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Property::Value *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - Dali::Property::Value *arg2 = 0 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Property::Value *)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::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_EqualTo(void * jarg1, void * jarg2) { - bool jresult; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - Dali::Property::Value *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Value *)jarg1; - arg2 = (Dali::Property::Value *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Property::Value const *)arg1)->operator ==((Dali::Property::Value const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_NotEqualTo(void * jarg1, void * jarg2) { - bool jresult; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - Dali::Property::Value *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Value *)jarg1; - arg2 = (Dali::Property::Value *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Property::Value const *)arg1)->operator !=((Dali::Property::Value const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) { - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - - arg1 = (Dali::Property::Value *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) { - int jresult ; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - Dali::Property::Type result; - - arg1 = (Dali::Property::Value *)jarg1; - { - try { - result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, bool * jarg2) { - bool jresult ; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - bool *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Value *)jarg1; - arg2 = (bool *)jarg2; - { - try { - result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) { - bool jresult ; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - float *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Value *)jarg1; - arg2 = (float *)jarg2; - { - try { - result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) { - bool jresult ; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - int *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Value *)jarg1; - arg2 = (int *)jarg2; - { - try { - result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - Dali::Rect< int > *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Value *)jarg1; - arg2 = (Dali::Rect< int > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - Dali::Vector2 *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Value *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - Dali::Vector3 *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Value *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - Dali::Vector4 *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Value *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - Dali::Matrix3 *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Value *)jarg1; - arg2 = (Dali::Matrix3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - Dali::Matrix *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Value *)jarg1; - arg2 = (Dali::Matrix *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - Dali::AngleAxis *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Value *)jarg1; - arg2 = (Dali::AngleAxis *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - Dali::Quaternion *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Value *)jarg1; - arg2 = (Dali::Quaternion *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) { - bool jresult ; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - std::string *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Value *)jarg1; - - //typemap in - std::string temp; - arg2 = &temp; - - { - try { - result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //Typemap argout in c++ file. - //This will convert c++ string to c# string - *jarg2 = SWIG_csharp_string_callback(arg2->c_str()); - - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - Dali::Property::Array *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Value *)jarg1; - arg2 = (Dali::Property::Array *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - Dali::Property::Map *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Value *)jarg1; - arg2 = (Dali::Property::Map *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - Extents *arg2 = 0 ; - bool result; - - arg1 = (Dali::Property::Value *)jarg1; - arg2 = (Extents *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) { - void * jresult ; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - Dali::Property::Array *result = 0 ; - - arg1 = (Dali::Property::Value *)jarg1; - { - try { - result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) { - void * jresult ; - Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ; - Dali::Property::Map *result = 0 ; - - arg1 = (Dali::Property::Value *)jarg1; - { - try { - result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) { - char * jresult ; - Dali::Property::Type arg1 ; - char *result = 0 ; - - arg1 = (Dali::Property::Type)jarg1; - { - try { - result = (char *)Dali::PropertyTypes::GetName(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback((const char *)result); - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) { - bool jresult ; - Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ; - std::string *arg2 = 0 ; - Dali::Property::Map *arg3 = 0 ; - bool result; - - arg1 = (Dali::BaseObject *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Property::Map *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); - return 0; - } - { - try { - result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) { - char * jresult ; - Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ; - std::string *result = 0 ; - - arg1 = (Dali::BaseObject *)jarg1; - { - try { - result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) { - bool jresult ; - Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ; - Dali::TypeInfo *arg2 = 0 ; - bool result; - - arg1 = (Dali::BaseObject *)jarg1; - arg2 = (Dali::TypeInfo *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) { - bool jresult ; - Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ; - ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ; - std::string *arg3 = 0 ; - FunctorDelegate *arg4 = (FunctorDelegate *) 0 ; - bool result; - - arg1 = (Dali::BaseObject *)jarg1; - arg2 = (ConnectionTrackerInterface *)jarg2; - if (!jarg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg3_str(jarg3); - arg3 = &arg3_str; - arg4 = (FunctorDelegate *)jarg4; - { - try { - result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) { - void * jresult ; - Dali::BaseHandle *arg1 = 0 ; - Dali::BaseObject *result = 0 ; - - arg1 = (Dali::BaseHandle *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0); - return 0; - } - { - try { - result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) { - void * jresult ; - Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ; - Dali::BaseHandle *result = 0 ; - - arg1 = (Dali::BaseObject *)jarg1; - { - try { - result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() { - void * jresult ; - Dali::BaseHandle *result = 0 ; - - { - try { - result = (Dali::BaseHandle *)new Dali::BaseHandle(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) { - Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ; - - arg1 = (Dali::BaseHandle *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) { - void * jresult ; - Dali::BaseHandle *arg1 = 0 ; - Dali::BaseHandle *result = 0 ; - - arg1 = (Dali::BaseHandle *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0); - return 0; - } - { - try { - result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ; - Dali::BaseHandle *arg2 = 0 ; - Dali::BaseHandle *result = 0 ; - - 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 = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) { - bool jresult ; - Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ; - std::string *arg2 = 0 ; - Dali::Property::Map *arg3 = 0 ; - bool result; - - arg1 = (Dali::BaseHandle *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Property::Map *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); - return 0; - } - { - try { - result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) { - char * jresult ; - Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ; - std::string *result = 0 ; - - arg1 = (Dali::BaseHandle *)jarg1; - { - try { - result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) { - bool jresult ; - Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ; - Dali::TypeInfo *arg2 = 0 ; - bool result; - - arg1 = (Dali::BaseHandle *)jarg1; - arg2 = (Dali::TypeInfo *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) { - void * jresult ; - Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ; - Dali::BaseObject *result = 0 ; - - arg1 = (Dali::BaseHandle *)jarg1; - { - try { - result = (Dali::BaseObject *) &(arg1)->GetBaseObject(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) { - Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ; - - arg1 = (Dali::BaseHandle *)jarg1; - { - try { - (arg1)->Reset(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) { - bool 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 const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) { - bool 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 const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) { - void * jresult ; - Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ; - Dali::RefObject *result = 0 ; - - arg1 = (Dali::BaseHandle *)jarg1; - { - try { - result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) { - bool jresult ; - Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ; - bool result; - - arg1 = (Dali::BaseHandle *)jarg1; - { - try { - result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) { - bool 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_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) { - bool jresult ; - Dali::BaseHandle *arg1 = 0 ; - Dali::BaseHandle *arg2 = 0 ; - bool result; - - arg1 = (Dali::BaseHandle *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0); - return 0; - } - arg2 = (Dali::BaseHandle *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0); - return 0; - } - { - try { - result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) { - Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ; - - arg1 = (Dali::ConnectionTrackerInterface *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) { - Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ; - SlotObserver *arg2 = (SlotObserver *) 0 ; - CallbackBase *arg3 = (CallbackBase *) 0 ; - - arg1 = (Dali::ConnectionTrackerInterface *)jarg1; - arg2 = (SlotObserver *)jarg2; - arg3 = (CallbackBase *)jarg3; - { - try { - (arg1)->SignalConnected(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) { - Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ; - - arg1 = (Dali::SignalObserver *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) { - Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ; - Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; - Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; - - arg1 = (Dali::SignalObserver *)jarg1; - arg2 = (Dali::SlotObserver *)jarg2; - arg3 = (Dali::CallbackBase *)jarg3; - { - try { - (arg1)->SignalDisconnected(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) { - Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ; - - arg1 = (Dali::SlotObserver *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) { - Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ; - Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ; - - arg1 = (Dali::SlotObserver *)jarg1; - arg2 = (Dali::CallbackBase *)jarg2; - { - try { - (arg1)->SlotDisconnected(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) { - Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ; - - arg1 = (Dali::ConnectionTracker *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) { - Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ; - - arg1 = (Dali::ConnectionTracker *)jarg1; - { - try { - (arg1)->DisconnectAll(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) { - Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ; - Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; - Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; - - arg1 = (Dali::ConnectionTracker *)jarg1; - arg2 = (Dali::SlotObserver *)jarg2; - arg3 = (Dali::CallbackBase *)jarg3; - { - try { - (arg1)->SignalConnected(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) { - Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ; - Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; - Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; - - arg1 = (Dali::ConnectionTracker *)jarg1; - arg2 = (Dali::SlotObserver *)jarg2; - arg3 = (Dali::CallbackBase *)jarg3; - { - try { - (arg1)->SignalDisconnected(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ; - std::size_t result; - - arg1 = (Dali::ConnectionTracker *)jarg1; - { - try { - result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() { - void * jresult ; - Dali::ObjectRegistry *result = 0 ; - - { - try { - result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) { - Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ; - - arg1 = (Dali::ObjectRegistry *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) { - void * jresult ; - Dali::ObjectRegistry *arg1 = 0 ; - Dali::ObjectRegistry *result = 0 ; - - arg1 = (Dali::ObjectRegistry *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0); - return 0; - } - { - try { - result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ; - Dali::ObjectRegistry *arg2 = 0 ; - Dali::ObjectRegistry *result = 0 ; - - arg1 = (Dali::ObjectRegistry *)jarg1; - arg2 = (Dali::ObjectRegistry *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0); - return 0; - } - { - try { - result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) { - void * jresult ; - Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ; - Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ; - - arg1 = (Dali::ObjectRegistry *)jarg1; - { - try { - result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) { - void * jresult ; - Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ; - Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ; - - arg1 = (Dali::ObjectRegistry *)jarg1; - { - try { - result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() { - void * jresult ; - Dali::PropertyCondition *result = 0 ; - - { - try { - result = (Dali::PropertyCondition *)new Dali::PropertyCondition(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) { - Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ; - - arg1 = (Dali::PropertyCondition *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) { - void * jresult ; - Dali::PropertyCondition *arg1 = 0 ; - Dali::PropertyCondition *result = 0 ; - - arg1 = (Dali::PropertyCondition *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0); - return 0; - } - { - try { - result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ; - Dali::PropertyCondition *arg2 = 0 ; - Dali::PropertyCondition *result = 0 ; - - arg1 = (Dali::PropertyCondition *)jarg1; - arg2 = (Dali::PropertyCondition *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0); - return 0; - } - { - try { - result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) { - unsigned long jresult ; - Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ; - std::size_t result; - - arg1 = (Dali::PropertyCondition *)jarg1; - { - try { - result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) { - float jresult ; - Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ; - std::size_t arg2 ; - float result; - - arg1 = (Dali::PropertyCondition *)jarg1; - arg2 = (std::size_t)jarg2; - { - try { - result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) { - void * jresult ; - float arg1 ; - Dali::PropertyCondition result; - - arg1 = (float)jarg1; - { - try { - result = Dali::LessThanCondition(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) { - void * jresult ; - float arg1 ; - Dali::PropertyCondition result; - - arg1 = (float)jarg1; - { - try { - result = Dali::GreaterThanCondition(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) { - void * jresult ; - float arg1 ; - float arg2 ; - Dali::PropertyCondition result; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - { - try { - result = Dali::InsideCondition(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) { - void * jresult ; - float arg1 ; - float arg2 ; - Dali::PropertyCondition result; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - { - try { - result = Dali::OutsideCondition(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) { - void * jresult ; - float arg1 ; - float arg2 ; - Dali::PropertyCondition result; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - { - try { - result = Dali::StepCondition(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) { - void * jresult ; - float arg1 ; - Dali::PropertyCondition result; - - arg1 = (float)jarg1; - { - try { - result = Dali::StepCondition(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) { - void * jresult ; - Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ; - Dali::PropertyCondition result; - - arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0); - return 0; - } - { - try { - result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() { - void * jresult ; - Dali::PropertyNotification *result = 0 ; - - { - try { - result = (Dali::PropertyNotification *)new Dali::PropertyNotification(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::PropertyNotification 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::PropertyNotification::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) { - Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ; - - arg1 = (Dali::PropertyNotification *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) { - void * jresult ; - Dali::PropertyNotification *arg1 = 0 ; - Dali::PropertyNotification *result = 0 ; - - arg1 = (Dali::PropertyNotification *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0); - return 0; - } - { - try { - result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ; - Dali::PropertyNotification *arg2 = 0 ; - Dali::PropertyNotification *result = 0 ; - - arg1 = (Dali::PropertyNotification *)jarg1; - arg2 = (Dali::PropertyNotification *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0); - return 0; - } - { - try { - result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) { - void * jresult ; - Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ; - Dali::PropertyCondition result; - - arg1 = (Dali::PropertyNotification *)jarg1; - { - try { - result = (arg1)->GetCondition(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) { - void * jresult ; - Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ; - Dali::Handle result; - - arg1 = (Dali::PropertyNotification *)jarg1; - { - try { - result = ((Dali::PropertyNotification const *)arg1)->GetTarget(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Handle((const Dali::Handle &)result); - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) { - int jresult ; - Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ; - Dali::Property::Index result; - - arg1 = (Dali::PropertyNotification *)jarg1; - { - try { - result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) { - Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ; - Dali::PropertyNotification::NotifyMode arg2 ; - - arg1 = (Dali::PropertyNotification *)jarg1; - arg2 = (Dali::PropertyNotification::NotifyMode)jarg2; - { - try { - (arg1)->SetNotifyMode(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) { - int jresult ; - Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ; - Dali::PropertyNotification::NotifyMode result; - - arg1 = (Dali::PropertyNotification *)jarg1; - { - try { - result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) { - bool jresult ; - Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ; - bool result; - - arg1 = (Dali::PropertyNotification *)jarg1; - { - try { - result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) { - void * jresult ; - Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ; - Dali::PropertyNotifySignalType *result = 0 ; - - arg1 = (Dali::PropertyNotification *)jarg1; - { - try { - result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() { - void * jresult ; - Dali::Handle *result = 0 ; - - { - try { - result = (Dali::Handle *)new Dali::Handle(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() { - void * jresult ; - Dali::Handle result; - - { - try { - result = Dali::Handle::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Handle((const Dali::Handle &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) { - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - - arg1 = (Dali::Handle *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Handle *arg1 = 0 ; - Dali::Handle *result = 0 ; - - arg1 = (Dali::Handle *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - Dali::Handle *arg2 = 0 ; - Dali::Handle *result = 0 ; - - arg1 = (Dali::Handle *)jarg1; - arg2 = (Dali::Handle *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Handle 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::Handle::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Handle((const Dali::Handle &)result); - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) { - bool jresult ; - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - Dali::Handle::Capability arg2 ; - bool result; - - arg1 = (Dali::Handle *)jarg1; - arg2 = (Dali::Handle::Capability)jarg2; - { - try { - result = (bool)((Dali::Handle const *)arg1)->Supports(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) { - unsigned int jresult ; - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - unsigned int result; - - arg1 = (Dali::Handle *)jarg1; - { - try { - result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) { - char * jresult ; - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - Dali::Property::Index arg2 ; - std::string result; - - arg1 = (Dali::Handle *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - { - try { - result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback((&result)->c_str()); - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) { - int jresult ; - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - std::string *arg2 = 0 ; - Dali::Property::Index result; - - arg1 = (Dali::Handle *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) { - bool jresult ; - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - Dali::Property::Index arg2 ; - bool result; - - arg1 = (Dali::Handle *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - { - try { - result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) { - bool jresult ; - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - Dali::Property::Index arg2 ; - bool result; - - arg1 = (Dali::Handle *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - { - try { - result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) { - bool jresult ; - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - Dali::Property::Index arg2 ; - bool result; - - arg1 = (Dali::Handle *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - { - try { - result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) { - int jresult ; - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - Dali::Property::Index arg2 ; - Dali::Property::Type result; - - arg1 = (Dali::Handle *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - { - try { - result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) { - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - Dali::Property::Index arg2 ; - Dali::Property::Value *arg3 = 0 ; - - arg1 = (Dali::Handle *)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); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) { - int jresult ; - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - std::string *arg2 = 0 ; - Dali::Property::Value *arg3 = 0 ; - Dali::Property::Index result; - - arg1 = (Dali::Handle *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Property::Value *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) { - int jresult ; - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - std::string *arg2 = 0 ; - Dali::Property::Value *arg3 = 0 ; - Dali::Property::AccessMode arg4 ; - Dali::Property::Index result; - - arg1 = (Dali::Handle *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Property::Value *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); - return 0; - } - arg4 = (Dali::Property::AccessMode)jarg4; - { - try { - result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) { - void * jresult ; - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - Dali::Property::Index arg2 ; - Dali::Property::Value result; - - arg1 = (Dali::Handle *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - { - try { - result = ((Dali::Handle const *)arg1)->GetProperty(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Property::Value((const Dali::Property::Value &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetCurrentProperty(void * jarg1, int jarg2) { - void * jresult ; - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - Dali::Property::Index arg2 ; - Dali::Property::Value result; - - arg1 = (Dali::Handle *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - { - try { - result = ((Dali::Handle const *)arg1)->GetCurrentProperty(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Property::Value((const Dali::Property::Value &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) { - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - Dali::Property::IndexContainer *arg2 = 0 ; - - arg1 = (Dali::Handle *)jarg1; - arg2 = (Dali::Property::IndexContainer *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0); - return ; - } - { - try { - ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) { - void * jresult ; - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - Dali::Property::Index arg2 ; - Dali::PropertyCondition *arg3 = 0 ; - Dali::PropertyNotification result; - - arg1 = (Dali::Handle *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - arg3 = (Dali::PropertyCondition *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0); - return 0; - } - { - try { - result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) { - void * jresult ; - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - Dali::Property::Index arg2 ; - int arg3 ; - Dali::PropertyCondition *arg4 = 0 ; - Dali::PropertyNotification result; - - arg1 = (Dali::Handle *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - arg3 = (int)jarg3; - arg4 = (Dali::PropertyCondition *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0); - return 0; - } - { - try { - result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) { - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - Dali::PropertyNotification arg2 ; - Dali::PropertyNotification *argp2 ; - - arg1 = (Dali::Handle *)jarg1; - argp2 = (Dali::PropertyNotification *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->RemovePropertyNotification(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) { - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - - arg1 = (Dali::Handle *)jarg1; - { - try { - (arg1)->RemovePropertyNotifications(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) { - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - - arg1 = (Dali::Handle *)jarg1; - { - try { - (arg1)->RemoveConstraints(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) { - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Handle *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - (arg1)->RemoveConstraints(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() { - int jresult ; - Dali::Property::Index result; - - result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT; - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() { - void * jresult ; - Dali::Handle result; - - { - try { - result = Dali::WeightObject::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Handle((const Dali::Handle &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() { - void * jresult ; - Dali::TypeInfo *result = 0 ; - - { - try { - result = (Dali::TypeInfo *)new Dali::TypeInfo(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) { - Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; - - arg1 = (Dali::TypeInfo *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) { - void * jresult ; - Dali::TypeInfo *arg1 = 0 ; - Dali::TypeInfo *result = 0 ; - - arg1 = (Dali::TypeInfo *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0); - return 0; - } - { - try { - result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; - Dali::TypeInfo *arg2 = 0 ; - Dali::TypeInfo *result = 0 ; - - arg1 = (Dali::TypeInfo *)jarg1; - arg2 = (Dali::TypeInfo *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0); - return 0; - } - { - try { - result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) { - char * jresult ; - Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; - std::string *result = 0 ; - - arg1 = (Dali::TypeInfo *)jarg1; - { - try { - result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) { - char * jresult ; - Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; - std::string *result = 0 ; - - arg1 = (Dali::TypeInfo *)jarg1; - { - try { - result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) { - void * jresult ; - Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; - Dali::BaseHandle result; - - arg1 = (Dali::TypeInfo *)jarg1; - { - try { - result = ((Dali::TypeInfo const *)arg1)->CreateInstance(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result); - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) { - unsigned long jresult ; - Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; - size_t result; - - arg1 = (Dali::TypeInfo *)jarg1; - { - try { - result = ((Dali::TypeInfo const *)arg1)->GetActionCount(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) { - char * jresult ; - Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; - size_t arg2 ; - std::string result; - - arg1 = (Dali::TypeInfo *)jarg1; - arg2 = (size_t)jarg2; - { - try { - result = (arg1)->GetActionName(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback((&result)->c_str()); - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) { - unsigned long jresult ; - Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; - size_t result; - - arg1 = (Dali::TypeInfo *)jarg1; - { - try { - result = ((Dali::TypeInfo const *)arg1)->GetSignalCount(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) { - char * jresult ; - Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; - size_t arg2 ; - std::string result; - - arg1 = (Dali::TypeInfo *)jarg1; - arg2 = (size_t)jarg2; - { - try { - result = (arg1)->GetSignalName(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback((&result)->c_str()); - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) { - unsigned long jresult ; - Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; - size_t result; - - arg1 = (Dali::TypeInfo *)jarg1; - { - try { - result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) { - Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; - Dali::Property::IndexContainer *arg2 = 0 ; - - arg1 = (Dali::TypeInfo *)jarg1; - arg2 = (Dali::Property::IndexContainer *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0); - return ; - } - { - try { - ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) { - char * jresult ; - Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ; - Dali::Property::Index arg2 ; - std::string_view result; - - arg1 = (Dali::TypeInfo *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - { - try { - result = ((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback(result.data()); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() { - void * jresult ; - Dali::TypeRegistry result; - - { - try { - result = Dali::TypeRegistry::Get(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() { - void * jresult ; - Dali::TypeRegistry *result = 0 ; - - { - try { - result = (Dali::TypeRegistry *)new Dali::TypeRegistry(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) { - Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ; - - arg1 = (Dali::TypeRegistry *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) { - void * jresult ; - Dali::TypeRegistry *arg1 = 0 ; - Dali::TypeRegistry *result = 0 ; - - arg1 = (Dali::TypeRegistry *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0); - return 0; - } - { - try { - result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ; - Dali::TypeRegistry *arg2 = 0 ; - Dali::TypeRegistry *result = 0 ; - - arg1 = (Dali::TypeRegistry *)jarg1; - arg2 = (Dali::TypeRegistry *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0); - return 0; - } - { - try { - result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) { - void * jresult ; - Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ; - std::string *arg2 = 0 ; - Dali::TypeInfo result; - - arg1 = (Dali::TypeRegistry *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - result = (arg1)->GetTypeInfo((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) { - void * jresult ; - Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ; - std::type_info *arg2 = 0 ; - Dali::TypeInfo result; - - arg1 = (Dali::TypeRegistry *)jarg1; - arg2 = (std::type_info *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0); - return 0; - } - { - try { - result = (arg1)->GetTypeInfo((std::type_info const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result); - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) { - unsigned long jresult ; - Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ; - size_t result; - - arg1 = (Dali::TypeRegistry *)jarg1; - { - try { - result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) { - char * jresult ; - Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ; - size_t arg2 ; - std::string result; - - arg1 = (Dali::TypeRegistry *)jarg1; - arg2 = (size_t)jarg2; - { - try { - result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback((&result)->c_str()); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { - void * jresult ; - std::type_info *arg1 = 0 ; - std::type_info *arg2 = 0 ; - Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ; - Dali::TypeRegistration *result = 0 ; - - arg1 = (std::type_info *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0); - return 0; - } - arg2 = (std::type_info *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0); - return 0; - } - arg3 = (Dali::TypeInfo::CreateFunction)jarg3; - { - try { - result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, bool jarg4) { - void * jresult ; - std::type_info *arg1 = 0 ; - std::type_info *arg2 = 0 ; - Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ; - bool arg4 ; - Dali::TypeRegistration *result = 0 ; - - arg1 = (std::type_info *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0); - return 0; - } - arg2 = (std::type_info *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0); - return 0; - } - arg3 = (Dali::TypeInfo::CreateFunction)jarg3; - arg4 = jarg4 ? true : false; - { - try { - result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) { - void * jresult ; - std::string *arg1 = 0 ; - std::type_info *arg2 = 0 ; - Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ; - Dali::TypeRegistration *result = 0 ; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - arg2 = (std::type_info *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0); - return 0; - } - arg3 = (Dali::TypeInfo::CreateFunction)jarg3; - { - try { - result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) { - char * jresult ; - Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ; - std::string result; - - arg1 = (Dali::TypeRegistration *)jarg1; - { - try { - result = ((Dali::TypeRegistration const *)arg1)->RegisteredName(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback((&result)->c_str()); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) { - std::string *arg1 = 0 ; - Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2; - { - try { - Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - - - //argout typemap for const std::string& - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) { - std::string *arg1 = 0 ; - std::string *arg2 = 0 ; - int arg3 ; - Dali::Property::Type arg4 ; - Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ; - Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (int)jarg3; - arg4 = (Dali::Property::Type)jarg4; - arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5; - arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6; - { - try { - Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6); - } CALL_CATCH_EXCEPTION(); - } - - - //argout typemap for const std::string& - - - //argout typemap for const std::string& - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) { - Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ; - - arg1 = (Dali::TypeRegistration *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) { - void * jresult ; - Dali::TypeRegistration *arg1 = 0 ; - std::string *arg2 = 0 ; - Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ; - Dali::SignalConnectorType *result = 0 ; - - arg1 = (Dali::TypeRegistration *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0); - return 0; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3; - { - try { - result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) { - Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ; - - arg1 = (Dali::SignalConnectorType *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) { - void * jresult ; - Dali::TypeRegistration *arg1 = 0 ; - std::string *arg2 = 0 ; - Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ; - Dali::TypeAction *result = 0 ; - - arg1 = (Dali::TypeRegistration *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0); - return 0; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::TypeInfo::ActionFunction)jarg3; - { - try { - result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) { - Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ; - - arg1 = (Dali::TypeAction *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) { - void * jresult ; - Dali::TypeRegistration *arg1 = 0 ; - std::string *arg2 = 0 ; - Dali::Property::Index arg3 ; - Dali::Property::Type arg4 ; - Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ; - Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ; - Dali::PropertyRegistration *result = 0 ; - - arg1 = (Dali::TypeRegistration *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0); - return 0; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Property::Index)jarg3; - arg4 = (Dali::Property::Type)jarg4; - arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5; - arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6; - { - try { - result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) { - Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ; - - arg1 = (Dali::PropertyRegistration *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) { - void * jresult ; - Dali::TypeRegistration *arg1 = 0 ; - std::string *arg2 = 0 ; - Dali::Property::Index arg3 ; - Dali::Property::Type arg4 ; - Dali::AnimatablePropertyRegistration *result = 0 ; - - arg1 = (Dali::TypeRegistration *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0); - return 0; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Property::Index)jarg3; - arg4 = (Dali::Property::Type)jarg4; - { - try { - result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) { - void * jresult ; - Dali::TypeRegistration *arg1 = 0 ; - std::string *arg2 = 0 ; - Dali::Property::Index arg3 ; - Dali::Property::Value *arg4 = 0 ; - Dali::AnimatablePropertyRegistration *result = 0 ; - - arg1 = (Dali::TypeRegistration *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0); - return 0; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Property::Index)jarg3; - arg4 = (Dali::Property::Value *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); - return 0; - } - { - try { - result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) { - Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ; - - arg1 = (Dali::AnimatablePropertyRegistration *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) { - void * jresult ; - Dali::TypeRegistration *arg1 = 0 ; - std::string *arg2 = 0 ; - Dali::Property::Index arg3 ; - Dali::Property::Index arg4 ; - unsigned int arg5 ; - Dali::AnimatablePropertyComponentRegistration *result = 0 ; - - arg1 = (Dali::TypeRegistration *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0); - return 0; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Property::Index)jarg3; - arg4 = (Dali::Property::Index)jarg4; - arg5 = (unsigned int)jarg5; - { - try { - result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) { - Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ; - - arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) { - void * jresult ; - Dali::TypeRegistration *arg1 = 0 ; - std::string *arg2 = 0 ; - Dali::Property::Index arg3 ; - Dali::Property::Type arg4 ; - Dali::ChildPropertyRegistration *result = 0 ; - - arg1 = (Dali::TypeRegistration *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0); - return 0; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Property::Index)jarg3; - arg4 = (Dali::Property::Type)jarg4; - { - try { - result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) { - Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ; - - arg1 = (Dali::ChildPropertyRegistration *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) { - bool jresult ; - std::string *arg1 = 0 ; - std::type_info *arg2 = 0 ; - Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ; - bool result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - arg2 = (std::type_info *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0); - return 0; - } - arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3; - { - try { - result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) { - bool jresult ; - std::string *arg1 = 0 ; - std::string *arg2 = 0 ; - Dali::Property::Index arg3 ; - Dali::Property::Type arg4 ; - Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ; - Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ; - bool result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Property::Index)jarg3; - arg4 = (Dali::Property::Type)jarg4; - arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5; - arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6; - { - try { - result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() { - float jresult ; - float result; - - result = (float)(float)Dali::ParentOrigin::TOP; - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() { - float jresult ; - float result; - - result = (float)(float)Dali::ParentOrigin::BOTTOM; - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() { - float jresult ; - float result; - - result = (float)(float)Dali::ParentOrigin::LEFT; - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() { - float jresult ; - float result; - - result = (float)(float)Dali::ParentOrigin::RIGHT; - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() { - float jresult ; - float result; - - result = (float)(float)Dali::ParentOrigin::MIDDLE; - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() { - float jresult ; - float result; - - result = (float)(float)Dali::AnchorPoint::TOP; - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() { - float jresult ; - float result; - - result = (float)(float)Dali::AnchorPoint::BOTTOM; - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() { - float jresult ; - float result; - - result = (float)(float)Dali::AnchorPoint::LEFT; - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() { - float jresult ; - float result; - - result = (float)(float)Dali::AnchorPoint::RIGHT; - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() { - float jresult ; - float result; - - result = (float)(float)Dali::AnchorPoint::MIDDLE; - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() { - void * jresult ; - Dali::Vector3 *result = 0 ; - - result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ALICE_BLUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::ALICE_BLUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANTIQUE_WHITE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::ANTIQUE_WHITE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AQUA_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::AQUA; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AQUA_MARINE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::AQUA_MARINE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AZURE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::AZURE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BEIGE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::BEIGE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BISQUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::BISQUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::BLACK; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLANCHE_DALMOND_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::BLANCHE_DALMOND; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::BLUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_VIOLET_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::BLUE_VIOLET; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BROWN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::BROWN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BURLY_WOOD_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::BURLY_WOOD; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CADET_BLUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::CADET_BLUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CHARTREUSE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::CHARTREUSE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CHOCOLATE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::CHOCOLATE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORAL_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::CORAL; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORNFLOWER_BLUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::CORNFLOWER_BLUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CORNSILK_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::CORNSILK; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CRIMSON_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::CRIMSON; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::CYAN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_BLUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DARK_BLUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_CYAN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DARK_CYAN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GOLDENROD_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DARK_GOLDENROD; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GRAY_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DARK_GRAY; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GREEN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DARK_GREEN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_GREY_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DARK_GREY; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_KHAKI_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DARK_KHAKI; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_MAGENTA_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DARK_MAGENTA; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_OLIVE_GREEN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DARK_OLIVE_GREEN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_ORANGE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DARK_ORANGE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_ORCHID_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DARK_ORCHID; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_RED_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DARK_RED; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SALMON_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DARK_SALMON; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SEA_GREEN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DARK_SEA_GREEN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_BLUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_BLUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_GRAY_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_GRAY; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_SLATE_GREY_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DARK_SLATE_GREY; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_TURQUOISE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DARK_TURQUOISE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DARK_VIOLET_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DARK_VIOLET; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DEEP_PINK_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DEEP_PINK; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DEEP_SKY_BLUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DEEP_SKY_BLUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DIM_GRAY_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DIM_GRAY; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DIM_GREY_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DIM_GREY; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DODGER_BLUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::DODGER_BLUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FIRE_BRICK_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::FIRE_BRICK; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FLORAL_WHITE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::FLORAL_WHITE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FOREST_GREEN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::FOREST_GREEN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FUCHSIA_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::FUCHSIA; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GAINSBORO_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::GAINSBORO; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GHOST_WHITE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::GHOST_WHITE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GOLD_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::GOLD; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GOLDEN_ROD_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::GOLDEN_ROD; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GRAY_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::GRAY; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::GREEN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_YELLOW_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::GREEN_YELLOW; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREY_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::GREY; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_HONEYDEW_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::HONEYDEW; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_HOT_PINK_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::HOT_PINK; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_INDIANRED_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::INDIANRED; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_INDIGO_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::INDIGO; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_IVORY_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::IVORY; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KHAKI_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::KHAKI; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAVENDER_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LAVENDER; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAVENDER_BLUSH_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LAVENDER_BLUSH; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LAWN_GREEN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LAWN_GREEN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LEMON_CHIFFON_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LEMON_CHIFFON; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_BLUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LIGHT_BLUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_CORAL_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LIGHT_CORAL; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_CYAN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LIGHT_CYAN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GOLDEN_ROD_YELLOW_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LIGHT_GOLDEN_ROD_YELLOW; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GRAY_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LIGHT_GRAY; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GREEN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LIGHT_GREEN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_GREY_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LIGHT_GREY; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_PINK_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LIGHT_PINK; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SALMON_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LIGHT_SALMON; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SEA_GREEN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LIGHT_SEA_GREEN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SKY_BLUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LIGHT_SKY_BLUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SLATE_GRAY_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LIGHT_SLATE_GRAY; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_SLATE_GREY_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LIGHT_SLATE_GREY; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_STEEL_BLUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LIGHT_STEEL_BLUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIGHT_YELLOW_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LIGHT_YELLOW; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIME_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LIME; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LIME_GREEN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LIME_GREEN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LINEN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::LINEN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::MAGENTA; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAROON_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::MAROON; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_AQUA_MARINE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::MEDIUM_AQUA_MARINE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_BLUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::MEDIUM_BLUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_ORCHID_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::MEDIUM_ORCHID; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_PURPLE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::MEDIUM_PURPLE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SEA_GREEN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SEA_GREEN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SLATE_BLUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SLATE_BLUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_SPRING_GREEN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::MEDIUM_SPRING_GREEN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_TURQUOISE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::MEDIUM_TURQUOISE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MEDIUM_VIOLETRED_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::MEDIUM_VIOLETRED; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MIDNIGHT_BLUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::MIDNIGHT_BLUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MINT_CREAM_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::MINT_CREAM; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MISTY_ROSE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::MISTY_ROSE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MOCCASIN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::MOCCASIN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NAVAJO_WHITE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::NAVAJO_WHITE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NAVY_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::NAVY; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLD_LACE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::OLD_LACE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLIVE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::OLIVE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OLIVE_DRAB_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::OLIVE_DRAB; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORANGE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::ORANGE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORANGE_RED_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::ORANGE_RED; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ORCHID_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::ORCHID; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_GOLDEN_ROD_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::PALE_GOLDEN_ROD; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_GREEN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::PALE_GREEN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_TURQUOISE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::PALE_TURQUOISE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PALE_VIOLET_RED_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::PALE_VIOLET_RED; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PAPAYA_WHIP_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::PAPAYA_WHIP; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PEACH_PUFF_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::PEACH_PUFF; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PERU_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::PERU; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PINK_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::PINK; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PLUM_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::PLUM; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_POWDER_BLUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::POWDER_BLUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PURPLE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::PURPLE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::RED; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ROSY_BROWN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::ROSY_BROWN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ROYAL_BLUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::ROYAL_BLUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SADDLE_BROWN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::SADDLE_BROWN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SALMON_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::SALMON; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SANDY_BROWN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::SANDY_BROWN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SEA_GREEN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::SEA_GREEN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SEA_SHELL_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::SEA_SHELL; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SIENNA_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::SIENNA; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SILVER_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::SILVER; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SKY_BLUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::SKY_BLUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_BLUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::SLATE_BLUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_GRAY_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::SLATE_GRAY; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SLATE_GREY_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::SLATE_GREY; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SNOW_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::SNOW; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_SPRING_GREEN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::SPRING_GREEN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_STEEL_BLUE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::STEEL_BLUE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TAN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::TAN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TEAL_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::TEAL; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_THISTLE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::THISTLE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TOMATO_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::TOMATO; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TURQUOISE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::TURQUOISE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VIOLET_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::VIOLET; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHEAT_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::WHEAT; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::WHITE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_SMOKE_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::WHITE_SMOKE; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::YELLOW; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_GREEN_get() { - void * jresult; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::Color::YELLOW_GREEN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() { - float jresult ; - float result; - - result = (float)(float)Dali::Math::MACHINE_EPSILON_0; - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() { - float jresult ; - float result; - - result = (float)(float)Dali::Math::MACHINE_EPSILON_1; - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() { - float jresult ; - float result; - - result = (float)(float)Dali::Math::MACHINE_EPSILON_10; - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() { - float jresult ; - float result; - - result = (float)(float)Dali::Math::MACHINE_EPSILON_100; - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() { - float jresult ; - float result; - - result = (float)(float)Dali::Math::MACHINE_EPSILON_1000; - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() { - float jresult ; - float result; - - result = (float)(float)Dali::Math::MACHINE_EPSILON_10000; - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() { - float jresult ; - float result; - - result = (float)(float)Dali::Math::PI; - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() { - float jresult ; - float result; - - result = (float)(float)Dali::Math::PI_2; - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() { - float jresult ; - float result; - - result = (float)(float)Dali::Math::PI_4; - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() { - float jresult ; - float result; - - result = (float)(float)Dali::Math::PI_OVER_180; - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() { - float jresult ; - float result; - - result = (float)(float)Dali::Math::ONE80_OVER_PI; - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() { - int jresult ; - Dali::ResizePolicy::Type result; - - result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) { - unsigned long jresult ; - Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ; - Dali::VectorBase::SizeType result; - - arg1 = (Dali::VectorBase *)jarg1; - { - try { - result = ((Dali::VectorBase const *)arg1)->Count(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) { - unsigned long jresult ; - Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ; - Dali::VectorBase::SizeType result; - - arg1 = (Dali::VectorBase *)jarg1; - { - try { - result = ((Dali::VectorBase const *)arg1)->Size(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) { - bool jresult ; - Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ; - bool result; - - arg1 = (Dali::VectorBase *)jarg1; - { - try { - result = (bool)((Dali::VectorBase const *)arg1)->Empty(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) { - unsigned long jresult ; - Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ; - Dali::VectorBase::SizeType result; - - arg1 = (Dali::VectorBase *)jarg1; - { - try { - result = ((Dali::VectorBase const *)arg1)->Capacity(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) { - Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ; - - arg1 = (Dali::VectorBase *)jarg1; - { - try { - (arg1)->Release(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() { - int jresult ; - Dali::Pixel::Format result; - - result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() { - int jresult ; - Dali::Pixel::Format result; - - result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) { - bool jresult ; - Dali::Pixel::Format arg1 ; - bool result; - - arg1 = (Dali::Pixel::Format)jarg1; - { - try { - result = (bool)Dali::Pixel::HasAlpha(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) { - unsigned int jresult ; - Dali::Pixel::Format arg1 ; - unsigned int result; - - arg1 = (Dali::Pixel::Format)jarg1; - { - try { - result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) { - Dali::Pixel::Format arg1 ; - int *arg2 = 0 ; - int *arg3 = 0 ; - - arg1 = (Dali::Pixel::Format)jarg1; - arg2 = (int *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0); - return ; - } - arg3 = (int *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0); - return ; - } - { - try { - Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* nuiBuffer, unsigned int nuiBufferSize, unsigned int nuiWidth, unsigned int nuiHeight, int nuiPixelFormat) { - void * jresult ; - Dali::PixelData result; - - { - unsigned char* copiedBuffer; - try - { - copiedBuffer = new unsigned char[nuiBufferSize]; - } CALL_CATCH_EXCEPTION(0); - - try - { - // Note : copiedBuffer created by 'new' method. So ReleaseFunction always be DELETE_ARRAY. - memcpy(copiedBuffer, nuiBuffer, nuiBufferSize); - result = Dali::PixelData::New(copiedBuffer, nuiBufferSize, nuiWidth, nuiHeight, (Dali::Pixel::Format)nuiPixelFormat, Dali::PixelData::ReleaseFunction::DELETE_ARRAY); - } CALL_CATCH_EXCEPTION_WITH_FUNCTION(0, [](unsigned char* buffer){delete[] buffer;}, copiedBuffer); - } - - jresult = new Dali::PixelData((const Dali::PixelData &)result); - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() { - void * jresult ; - Dali::PixelData *result = 0 ; - - { - try { - result = (Dali::PixelData *)new Dali::PixelData(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * nuiHandle) { - Dali::PixelData *pixelData = (Dali::PixelData *) 0 ; - - pixelData = (Dali::PixelData *)nuiHandle; - { - try { - delete pixelData; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * nuiHandle) { - void * jresult ; - Dali::PixelData *pixelData = 0 ; - Dali::PixelData *result = 0 ; - - pixelData = (Dali::PixelData *)nuiHandle; - if (!pixelData) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0); - return 0; - } - { - try { - result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*pixelData); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * nuiHandle, void * nuiHandleSource) { - void * jresult ; - Dali::PixelData *pixelData = (Dali::PixelData *) 0 ; - Dali::PixelData *pixelDataSource = 0 ; - Dali::PixelData *result = 0 ; - - pixelData = (Dali::PixelData *)nuiHandle; - pixelDataSource = (Dali::PixelData *)nuiHandleSource; - if (!pixelDataSource) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0); - return 0; - } - { - try { - result = (Dali::PixelData *) &(pixelData)->operator =((Dali::PixelData const &)*pixelDataSource); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * nuiHandle) { - unsigned int jresult ; - Dali::PixelData *pixelData = (Dali::PixelData *) 0 ; - unsigned int result; - - pixelData = (Dali::PixelData *)nuiHandle; - { - try { - result = (unsigned int)((Dali::PixelData const *)pixelData)->GetWidth(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * nuiHandle) { - unsigned int jresult ; - Dali::PixelData *pixelData = (Dali::PixelData *) 0 ; - unsigned int result; - - pixelData = (Dali::PixelData *)nuiHandle; - { - try { - result = (unsigned int)((Dali::PixelData const *)pixelData)->GetHeight(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * nuiHandle) { - int jresult ; - Dali::PixelData *pixelData = (Dali::PixelData *) 0 ; - Dali::Pixel::Format result; - - pixelData = (Dali::PixelData *)nuiHandle; - { - try { - result = (Dali::Pixel::Format)((Dali::PixelData const *)pixelData)->GetPixelFormat(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PixelData_GenerateUrl(void* nuiHandle) -{ - Dali::PixelData *pixelData = (Dali::PixelData*)nuiHandle; - Dali::Toolkit::ImageUrl result; - void *jresult; - - if (!pixelData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); - return 0; - } - { - try - { - result = Dali::Toolkit::Image::GenerateUrl(*pixelData); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl&)result); - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() { - unsigned int jresult ; - unsigned int result; - - result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X; - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() { - unsigned int jresult ; - unsigned int result; - - result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X; - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() { - unsigned int jresult ; - unsigned int result; - - result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y; - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() { - unsigned int jresult ; - unsigned int result; - - result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y; - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() { - unsigned int jresult ; - unsigned int result; - - result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z; - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() { - unsigned int jresult ; - unsigned int result; - - result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z; - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) { - void * jresult ; - Dali::TextureType::Type arg1 ; - Dali::Pixel::Format arg2 ; - unsigned int arg3 ; - unsigned int arg4 ; - Dali::Texture result; - - arg1 = (Dali::TextureType::Type)jarg1; - arg2 = (Dali::Pixel::Format)jarg2; - arg3 = (unsigned int)jarg3; - arg4 = (unsigned int)jarg4; - { - try { - result = Dali::Texture::New(arg1,arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Texture((const Dali::Texture &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) { - void * jresult ; - NativeImageInterface *arg1 = 0 ; - Dali::Texture result; - - arg1 = (NativeImageInterface *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0); - return 0; - } - { - try { - result = Dali::Texture::New(*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Texture((const Dali::Texture &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() { - void * jresult ; - Dali::Texture *result = 0 ; - - { - try { - result = (Dali::Texture *)new Dali::Texture(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) { - Dali::Texture *arg1 = (Dali::Texture *) 0 ; - - arg1 = (Dali::Texture *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Texture *arg1 = 0 ; - Dali::Texture *result = 0 ; - - arg1 = (Dali::Texture *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Texture 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::Texture::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Texture((const Dali::Texture &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Texture *arg1 = (Dali::Texture *) 0 ; - Dali::Texture *arg2 = 0 ; - Dali::Texture *result = 0 ; - - arg1 = (Dali::Texture *)jarg1; - arg2 = (Dali::Texture *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Texture *arg1 = (Dali::Texture *) 0 ; - Dali::PixelData arg2 ; - Dali::PixelData *argp2 ; - bool result; - - arg1 = (Dali::Texture *)jarg1; - argp2 = (Dali::PixelData *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (bool)(arg1)->Upload(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, unsigned int jarg6, unsigned int jarg7, unsigned int jarg8) { - bool jresult ; - Dali::Texture *arg1 = (Dali::Texture *) 0 ; - Dali::PixelData arg2 ; - unsigned int arg3 ; - unsigned int arg4 ; - unsigned int arg5 ; - unsigned int arg6 ; - unsigned int arg7 ; - unsigned int arg8 ; - Dali::PixelData *argp2 ; - bool result; - - arg1 = (Dali::Texture *)jarg1; - argp2 = (Dali::PixelData *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0); - return 0; - } - arg2 = *argp2; - arg3 = (unsigned int)jarg3; - arg4 = (unsigned int)jarg4; - arg5 = (unsigned int)jarg5; - arg6 = (unsigned int)jarg6; - arg7 = (unsigned int)jarg7; - arg8 = (unsigned int)jarg8; - { - try { - result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) { - Dali::Texture *arg1 = (Dali::Texture *) 0 ; - - arg1 = (Dali::Texture *)jarg1; - { - try { - (arg1)->GenerateMipmaps(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) { - unsigned int jresult ; - Dali::Texture *arg1 = (Dali::Texture *) 0 ; - unsigned int result; - - arg1 = (Dali::Texture *)jarg1; - { - try { - result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) { - unsigned int jresult ; - Dali::Texture *arg1 = (Dali::Texture *) 0 ; - unsigned int result; - - arg1 = (Dali::Texture *)jarg1; - { - try { - result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() { - void * jresult ; - Dali::Sampler result; - - { - try { - result = Dali::Sampler::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Sampler((const Dali::Sampler &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() { - void * jresult ; - Dali::Sampler *result = 0 ; - - { - try { - result = (Dali::Sampler *)new Dali::Sampler(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) { - Dali::Sampler *arg1 = (Dali::Sampler *) 0 ; - - arg1 = (Dali::Sampler *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Sampler *arg1 = 0 ; - Dali::Sampler *result = 0 ; - - arg1 = (Dali::Sampler *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Sampler 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::Sampler::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Sampler((const Dali::Sampler &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Sampler *arg1 = (Dali::Sampler *) 0 ; - Dali::Sampler *arg2 = 0 ; - Dali::Sampler *result = 0 ; - - arg1 = (Dali::Sampler *)jarg1; - arg2 = (Dali::Sampler *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) { - Dali::Sampler *arg1 = (Dali::Sampler *) 0 ; - Dali::FilterMode::Type arg2 ; - Dali::FilterMode::Type arg3 ; - - arg1 = (Dali::Sampler *)jarg1; - arg2 = (Dali::FilterMode::Type)jarg2; - arg3 = (Dali::FilterMode::Type)jarg3; - { - try { - (arg1)->SetFilterMode(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) { - Dali::Sampler *arg1 = (Dali::Sampler *) 0 ; - Dali::WrapMode::Type arg2 ; - Dali::WrapMode::Type arg3 ; - - arg1 = (Dali::Sampler *)jarg1; - arg2 = (Dali::WrapMode::Type)jarg2; - arg3 = (Dali::WrapMode::Type)jarg3; - { - try { - (arg1)->SetWrapMode(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) { - Dali::Sampler *arg1 = (Dali::Sampler *) 0 ; - Dali::WrapMode::Type arg2 ; - Dali::WrapMode::Type arg3 ; - Dali::WrapMode::Type arg4 ; - - arg1 = (Dali::Sampler *)jarg1; - arg2 = (Dali::WrapMode::Type)jarg2; - arg3 = (Dali::WrapMode::Type)jarg3; - arg4 = (Dali::WrapMode::Type)jarg4; - { - try { - (arg1)->SetWrapMode(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() { - void * jresult ; - Dali::TextureSet result; - - { - try { - result = Dali::TextureSet::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::TextureSet((const Dali::TextureSet &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() { - void * jresult ; - Dali::TextureSet *result = 0 ; - - { - try { - result = (Dali::TextureSet *)new Dali::TextureSet(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) { - Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ; - - arg1 = (Dali::TextureSet *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) { - void * jresult ; - Dali::TextureSet *arg1 = 0 ; - Dali::TextureSet *result = 0 ; - - arg1 = (Dali::TextureSet *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0); - return 0; - } - { - try { - result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::TextureSet 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::TextureSet::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::TextureSet((const Dali::TextureSet &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ; - Dali::TextureSet *arg2 = 0 ; - Dali::TextureSet *result = 0 ; - - arg1 = (Dali::TextureSet *)jarg1; - arg2 = (Dali::TextureSet *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0); - return 0; - } - { - try { - result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) { - Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ; - size_t arg2 ; - Dali::Texture arg3 ; - Dali::Texture *argp3 ; - - arg1 = (Dali::TextureSet *)jarg1; - arg2 = (size_t)jarg2; - argp3 = (Dali::Texture *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0); - return ; - } - arg3 = *argp3; - { - try { - (arg1)->SetTexture(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ; - size_t arg2 ; - Dali::Texture result; - - arg1 = (Dali::TextureSet *)jarg1; - arg2 = (size_t)jarg2; - { - try { - result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Texture((const Dali::Texture &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) { - Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ; - size_t arg2 ; - Dali::Sampler arg3 ; - Dali::Sampler *argp3 ; - - arg1 = (Dali::TextureSet *)jarg1; - arg2 = (size_t)jarg2; - argp3 = (Dali::Sampler *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0); - return ; - } - arg3 = *argp3; - { - try { - (arg1)->SetSampler(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ; - size_t arg2 ; - Dali::Sampler result; - - arg1 = (Dali::TextureSet *)jarg1; - arg2 = (size_t)jarg2; - { - try { - result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Sampler((const Dali::Sampler &)result); - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) { - unsigned long jresult ; - Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ; - size_t result; - - arg1 = (Dali::TextureSet *)jarg1; - { - try { - result = ((Dali::TextureSet const *)arg1)->GetTextureCount(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_New(void * jarg1) { - void * jresult ; - Dali::Property::Map *arg1 = 0 ; - Dali::VertexBuffer result; - - arg1 = (Dali::Property::Map *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0); - return 0; - } - { - try { - result = Dali::VertexBuffer::New(*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_0() { - void * jresult ; - Dali::VertexBuffer *result = 0 ; - - { - try { - result = (Dali::VertexBuffer *)new Dali::VertexBuffer(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VertexBuffer(void * jarg1) { - Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ; - - arg1 = (Dali::VertexBuffer *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_1(void * jarg1) { - void * jresult ; - Dali::VertexBuffer *arg1 = 0 ; - Dali::VertexBuffer *result = 0 ; - - arg1 = (Dali::VertexBuffer *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0); - return 0; - } - { - try { - result = (Dali::VertexBuffer *)new Dali::VertexBuffer((Dali::VertexBuffer const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::VertexBuffer 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::VertexBuffer::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ; - Dali::VertexBuffer *arg2 = 0 ; - Dali::VertexBuffer *result = 0 ; - - arg1 = (Dali::VertexBuffer *)jarg1; - arg2 = (Dali::VertexBuffer *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0); - return 0; - } - { - try { - result = (Dali::VertexBuffer *) &(arg1)->operator =((Dali::VertexBuffer const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VertexBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) { - Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ; - void *arg2 = (void *) 0 ; - std::size_t arg3 ; - - arg1 = (Dali::VertexBuffer *)jarg1; - arg2 = jarg2; - arg3 = (std::size_t)jarg3; - { - try { - (arg1)->SetData((void const *)arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VertexBuffer_GetSize(void * jarg1) { - unsigned long jresult ; - Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ; - std::size_t result; - - arg1 = (Dali::VertexBuffer *)jarg1; - { - try { - result = ((Dali::VertexBuffer const *)arg1)->GetSize(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() { - void * jresult ; - Dali::Geometry result; - - { - try { - result = Dali::Geometry::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Geometry((const Dali::Geometry &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() { - void * jresult ; - Dali::Geometry *result = 0 ; - - { - try { - result = (Dali::Geometry *)new Dali::Geometry(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) { - Dali::Geometry *arg1 = (Dali::Geometry *) 0 ; - - arg1 = (Dali::Geometry *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Geometry *arg1 = 0 ; - Dali::Geometry *result = 0 ; - - arg1 = (Dali::Geometry *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Geometry 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::Geometry::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Geometry((const Dali::Geometry &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Geometry *arg1 = (Dali::Geometry *) 0 ; - Dali::Geometry *arg2 = 0 ; - Dali::Geometry *result = 0 ; - - arg1 = (Dali::Geometry *)jarg1; - arg2 = (Dali::Geometry *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) { - unsigned long jresult ; - Dali::Geometry *arg1 = (Dali::Geometry *) 0 ; - Dali::VertexBuffer *arg2 = 0 ; - std::size_t result; - - arg1 = (Dali::Geometry *)jarg1; - arg2 = (Dali::VertexBuffer *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer & type is null", 0); - return 0; - } - { - try { - result = (arg1)->AddVertexBuffer(*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) { - unsigned long jresult ; - Dali::Geometry *arg1 = (Dali::Geometry *) 0 ; - std::size_t result; - - arg1 = (Dali::Geometry *)jarg1; - { - try { - result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) { - Dali::Geometry *arg1 = (Dali::Geometry *) 0 ; - std::size_t arg2 ; - - arg1 = (Dali::Geometry *)jarg1; - arg2 = (std::size_t)jarg2; - { - try { - (arg1)->RemoveVertexBuffer(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) { - Dali::Geometry *arg1 = (Dali::Geometry *) 0 ; - unsigned short *arg2 = (unsigned short *) 0 ; - size_t arg3 ; - - arg1 = (Dali::Geometry *)jarg1; - arg2 = jarg2; - arg3 = (size_t)jarg3; - { - try { - (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - - - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) { - Dali::Geometry *arg1 = (Dali::Geometry *) 0 ; - Dali::Geometry::Type arg2 ; - - arg1 = (Dali::Geometry *)jarg1; - arg2 = (Dali::Geometry::Type)jarg2; - { - try { - (arg1)->SetType(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) { - int jresult ; - Dali::Geometry *arg1 = (Dali::Geometry *) 0 ; - Dali::Geometry::Type result; - - arg1 = (Dali::Geometry *)jarg1; - { - try { - result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() { - void * jresult ; - Dali::Shader::Hint *result = 0 ; - - { - try { - result = (Dali::Shader::Hint *)new Dali::Shader::Hint(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) { - Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ; - - arg1 = (Dali::Shader::Hint *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() { - int jresult ; - int result; - - result = (int)Dali::Shader::Property::PROGRAM; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() { - void * jresult ; - Dali::Shader::Property *result = 0 ; - - { - try { - result = (Dali::Shader::Property *)new Dali::Shader::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) { - Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ; - - arg1 = (Dali::Shader::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) { - void * jresult ; - std::string *arg1 = 0 ; - std::string *arg2 = 0 ; - Dali::Shader::Hint::Value arg3 ; - Dali::Shader result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Shader::Hint::Value)jarg3; - { - try { - result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Shader((const Dali::Shader &)result); - - //argout typemap for const std::string& - - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) { - void * jresult ; - std::string *arg1 = 0 ; - std::string *arg2 = 0 ; - Dali::Shader result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Shader((const Dali::Shader &)result); - - //argout typemap for const std::string& - - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() { - void * jresult ; - Dali::Shader *result = 0 ; - - { - try { - result = (Dali::Shader *)new Dali::Shader(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) { - Dali::Shader *arg1 = (Dali::Shader *) 0 ; - - arg1 = (Dali::Shader *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Shader *arg1 = 0 ; - Dali::Shader *result = 0 ; - - arg1 = (Dali::Shader *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Shader 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::Shader::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Shader((const Dali::Shader &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Shader *arg1 = (Dali::Shader *) 0 ; - Dali::Shader *arg2 = 0 ; - Dali::Shader *result = 0 ; - - arg1 = (Dali::Shader *)jarg1; - arg2 = (Dali::Shader *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::DEPTH_INDEX; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::FACE_CULLING_MODE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::BLEND_MODE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::BLEND_COLOR; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::DEPTH_FUNCTION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::RENDER_MODE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::STENCIL_FUNCTION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::STENCIL_MASK; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() { - int jresult ; - int result; - - result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() { - void * jresult ; - Dali::Renderer::Property *result = 0 ; - - { - try { - result = (Dali::Renderer::Property *)new Dali::Renderer::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) { - Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ; - - arg1 = (Dali::Renderer::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Geometry *arg1 = 0 ; - Dali::Shader *arg2 = 0 ; - Dali::Renderer result; - - arg1 = (Dali::Geometry *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0); - return 0; - } - arg2 = (Dali::Shader *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0); - return 0; - } - { - try { - result = Dali::Renderer::New(*arg1,*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Renderer((const Dali::Renderer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() { - void * jresult ; - Dali::Renderer *result = 0 ; - - { - try { - result = (Dali::Renderer *)new Dali::Renderer(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) { - Dali::Renderer *arg1 = (Dali::Renderer *) 0 ; - - arg1 = (Dali::Renderer *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Renderer *arg1 = 0 ; - Dali::Renderer *result = 0 ; - - arg1 = (Dali::Renderer *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Renderer 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::Renderer::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Renderer((const Dali::Renderer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Renderer *arg1 = (Dali::Renderer *) 0 ; - Dali::Renderer *arg2 = 0 ; - Dali::Renderer *result = 0 ; - - arg1 = (Dali::Renderer *)jarg1; - arg2 = (Dali::Renderer *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) { - Dali::Renderer *arg1 = (Dali::Renderer *) 0 ; - Dali::Geometry *arg2 = 0 ; - - arg1 = (Dali::Renderer *)jarg1; - arg2 = (Dali::Geometry *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0); - return ; - } - { - try { - (arg1)->SetGeometry(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) { - void * jresult ; - Dali::Renderer *arg1 = (Dali::Renderer *) 0 ; - Dali::Geometry result; - - arg1 = (Dali::Renderer *)jarg1; - { - try { - result = ((Dali::Renderer const *)arg1)->GetGeometry(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Geometry((const Dali::Geometry &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) { - Dali::Renderer *arg1 = (Dali::Renderer *) 0 ; - int arg2 ; - int arg3 ; - - arg1 = (Dali::Renderer *)jarg1; - arg2 = (int)jarg2; - arg3 = (int)jarg3; - { - try { - (arg1)->SetIndexRange(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) { - Dali::Renderer *arg1 = (Dali::Renderer *) 0 ; - Dali::TextureSet *arg2 = 0 ; - - arg1 = (Dali::Renderer *)jarg1; - arg2 = (Dali::TextureSet *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0); - return ; - } - { - try { - (arg1)->SetTextures(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) { - void * jresult ; - Dali::Renderer *arg1 = (Dali::Renderer *) 0 ; - Dali::TextureSet result; - - arg1 = (Dali::Renderer *)jarg1; - { - try { - result = ((Dali::Renderer const *)arg1)->GetTextures(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::TextureSet((const Dali::TextureSet &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) { - Dali::Renderer *arg1 = (Dali::Renderer *) 0 ; - Dali::Shader *arg2 = 0 ; - - arg1 = (Dali::Renderer *)jarg1; - arg2 = (Dali::Shader *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0); - return ; - } - { - try { - (arg1)->SetShader(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) { - void * jresult ; - Dali::Renderer *arg1 = (Dali::Renderer *) 0 ; - Dali::Shader result; - - arg1 = (Dali::Renderer *)jarg1; - { - try { - result = ((Dali::Renderer const *)arg1)->GetShader(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Shader((const Dali::Shader &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() { - void * jresult ; - Dali::FrameBuffer::Attachment *result = 0 ; - - { - try { - result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) { - Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ; - - arg1 = (Dali::FrameBuffer::Attachment *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) { - void * jresult ; - unsigned int arg1 ; - unsigned int arg2 ; - unsigned int arg3 ; - Dali::FrameBuffer result; - - arg1 = (unsigned int)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (unsigned int)jarg3; - { - try { - result = Dali::FrameBuffer::New(arg1,arg2,static_cast(arg3)); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() { - void * jresult ; - Dali::FrameBuffer *result = 0 ; - - { - try { - result = (Dali::FrameBuffer *)new Dali::FrameBuffer(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) { - Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ; - - arg1 = (Dali::FrameBuffer *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) { - void * jresult ; - Dali::FrameBuffer *arg1 = 0 ; - Dali::FrameBuffer *result = 0 ; - - arg1 = (Dali::FrameBuffer *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0); - return 0; - } - { - try { - result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::FrameBuffer 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::FrameBuffer::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ; - Dali::FrameBuffer *arg2 = 0 ; - Dali::FrameBuffer *result = 0 ; - - arg1 = (Dali::FrameBuffer *)jarg1; - arg2 = (Dali::FrameBuffer *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0); - return 0; - } - { - try { - result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) { - Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ; - Dali::Texture *arg2 = 0 ; - - arg1 = (Dali::FrameBuffer *)jarg1; - arg2 = (Dali::Texture *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0); - return ; - } - { - try { - (arg1)->AttachColorTexture(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) { - Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ; - Dali::Texture *arg2 = 0 ; - unsigned int arg3 ; - unsigned int arg4 ; - - arg1 = (Dali::FrameBuffer *)jarg1; - arg2 = (Dali::Texture *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0); - return ; - } - arg3 = (unsigned int)jarg3; - arg4 = (unsigned int)jarg4; - { - try { - (arg1)->AttachColorTexture(*arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) { - void * jresult ; - Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ; - Dali::Texture result; - - arg1 = (Dali::FrameBuffer *)jarg1; - { - try { - result = (arg1)->GetColorTexture(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Texture((const Dali::Texture &)result); - return jresult; -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_FrameBuffer_GenerateUrl(void *jFrameBuffer, int pixelFormat, int width, int height) -{ - void *jresult; - Dali::Toolkit::ImageUrl result; - Dali::FrameBuffer *frameBuffer = (Dali::FrameBuffer*)jFrameBuffer;; - - if (!frameBuffer) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer is null", 0); - return 0; - } - { - try - { - result = Dali::Toolkit::Image::GenerateUrl((const Dali::FrameBuffer&)*frameBuffer, (Pixel::Format)pixelFormat, (uint32_t)width, (uint32_t)height); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() { - void * jresult ; - Dali::RenderTaskList *result = 0 ; - - { - try { - result = (Dali::RenderTaskList *)new Dali::RenderTaskList(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::RenderTaskList 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::RenderTaskList::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) { - Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ; - - arg1 = (Dali::RenderTaskList *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) { - void * jresult ; - Dali::RenderTaskList *arg1 = 0 ; - Dali::RenderTaskList *result = 0 ; - - arg1 = (Dali::RenderTaskList *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0); - return 0; - } - { - try { - result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ; - Dali::RenderTaskList *arg2 = 0 ; - Dali::RenderTaskList *result = 0 ; - - arg1 = (Dali::RenderTaskList *)jarg1; - arg2 = (Dali::RenderTaskList *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0); - return 0; - } - { - try { - result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) { - void * jresult ; - Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ; - Dali::RenderTask result; - - arg1 = (Dali::RenderTaskList *)jarg1; - { - try { - result = (arg1)->CreateTask(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::RenderTask((const Dali::RenderTask &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) { - Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ; - Dali::RenderTask arg2 ; - Dali::RenderTask *argp2 ; - - arg1 = (Dali::RenderTaskList *)jarg1; - argp2 = (Dali::RenderTask *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->RemoveTask(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -//// ===============================================end part 1 ================= - -//// ========================= part 2 =============================== - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) { - unsigned int jresult ; - Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ; - unsigned int result; - - arg1 = (Dali::RenderTaskList *)jarg1; - { - try { - result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) { - void * jresult ; - Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ; - unsigned int arg2 ; - Dali::RenderTask result; - - arg1 = (Dali::RenderTaskList *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::RenderTask((const Dali::RenderTask &)result); - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() { - int jresult ; - int result; - - result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() { - int jresult ; - int result; - - result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() { - int jresult ; - int result; - - result = (int)Dali::RenderTask::Property::CLEAR_COLOR; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() { - int jresult ; - int result; - - result = (int)Dali::RenderTask::Property::REQUIRES_SYNC; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() { - void * jresult ; - Dali::RenderTask::Property *result = 0 ; - - { - try { - result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) { - Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ; - - arg1 = (Dali::RenderTask::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() { - void * jresult ; - bool (*result)(Dali::Vector2 &) = 0 ; - - result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() { - void * jresult ; - bool (*result)(Dali::Vector2 &) = 0 ; - - result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() { - bool jresult ; - bool result; - - result = (bool)Dali::RenderTask::DEFAULT_EXCLUSIVE; - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() { - bool jresult ; - bool result; - - result = (bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED; - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() { - void * jresult ; - Dali::Vector4 *result = 0 ; - - result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() { - bool jresult ; - bool result; - - result = (bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED; - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() { - bool jresult ; - bool result; - - result = (bool)Dali::RenderTask::DEFAULT_CULL_MODE; - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() { - unsigned int jresult ; - unsigned int result; - - result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE; - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() { - void * jresult ; - Dali::RenderTask *result = 0 ; - - { - try { - result = (Dali::RenderTask *)new Dali::RenderTask(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::RenderTask 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::RenderTask::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::RenderTask((const Dali::RenderTask &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) { - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - - arg1 = (Dali::RenderTask *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) { - void * jresult ; - Dali::RenderTask *arg1 = 0 ; - Dali::RenderTask *result = 0 ; - - arg1 = (Dali::RenderTask *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0); - return 0; - } - { - try { - result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::RenderTask *arg2 = 0 ; - Dali::RenderTask *result = 0 ; - - arg1 = (Dali::RenderTask *)jarg1; - arg2 = (Dali::RenderTask *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0); - return 0; - } - { - try { - result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) { - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::RenderTask *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetSourceActor(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) { - void * jresult ; - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::Actor result; - - arg1 = (Dali::RenderTask *)jarg1; - { - try { - result = ((Dali::RenderTask const *)arg1)->GetSourceActor(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, bool jarg2) { - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - bool arg2 ; - - arg1 = (Dali::RenderTask *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - (arg1)->SetExclusive(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) { - bool jresult ; - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - bool result; - - arg1 = (Dali::RenderTask *)jarg1; - { - try { - result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, bool jarg2) { - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - bool arg2 ; - - arg1 = (Dali::RenderTask *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - (arg1)->SetInputEnabled(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) { - bool jresult ; - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - bool result; - - arg1 = (Dali::RenderTask *)jarg1; - { - try { - result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) { - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::CameraActor arg2 ; - Dali::CameraActor *argp2 ; - - arg1 = (Dali::RenderTask *)jarg1; - argp2 = (Dali::CameraActor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetCameraActor(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) { - void * jresult ; - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::CameraActor result; - - arg1 = (Dali::RenderTask *)jarg1; - { - try { - result = ((Dali::RenderTask const *)arg1)->GetCameraActor(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::CameraActor((const Dali::CameraActor &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) { - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::FrameBuffer arg2 ; - Dali::FrameBuffer *argp2 ; - - arg1 = (Dali::RenderTask *)jarg1; - argp2 = (Dali::FrameBuffer *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetFrameBuffer(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) { - void * jresult ; - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::FrameBuffer result; - - arg1 = (Dali::RenderTask *)jarg1; - { - try { - result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) { - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ; - - arg1 = (Dali::RenderTask *)jarg1; - arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2; - { - try { - (arg1)->SetScreenToFrameBufferFunction(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) { - void * jresult ; - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::RenderTask::ScreenToFrameBufferFunction result; - - arg1 = (Dali::RenderTask *)jarg1; - { - try { - result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) { - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::RenderTask *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetScreenToFrameBufferMappingActor(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) { - void * jresult ; - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::Actor result; - - arg1 = (Dali::RenderTask *)jarg1; - { - try { - result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) { - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::Vector2 arg2 ; - Dali::Vector2 *argp2 ; - - arg1 = (Dali::RenderTask *)jarg1; - argp2 = (Dali::Vector2 *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetViewportPosition(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) { - void * jresult ; - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::RenderTask *)jarg1; - { - try { - result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) { - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::Vector2 arg2 ; - Dali::Vector2 *argp2 ; - - arg1 = (Dali::RenderTask *)jarg1; - argp2 = (Dali::Vector2 *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetViewportSize(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) { - void * jresult ; - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::RenderTask *)jarg1; - { - try { - result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) { - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::Viewport arg2 ; - Dali::Viewport *argp2 ; - - arg1 = (Dali::RenderTask *)jarg1; - argp2 = (Dali::Viewport *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetViewport(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) { - void * jresult ; - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::Viewport result; - - arg1 = (Dali::RenderTask *)jarg1; - { - try { - result = ((Dali::RenderTask const *)arg1)->GetViewport(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Viewport((const Dali::Viewport &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) { - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::Vector4 *arg2 = 0 ; - - arg1 = (Dali::RenderTask *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetClearColor((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) { - void * jresult ; - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::Vector4 result; - - arg1 = (Dali::RenderTask *)jarg1; - { - try { - result = ((Dali::RenderTask const *)arg1)->GetClearColor(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, bool jarg2) { - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - bool arg2 ; - - arg1 = (Dali::RenderTask *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - (arg1)->SetClearEnabled(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) { - bool jresult ; - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - bool result; - - arg1 = (Dali::RenderTask *)jarg1; - { - try { - result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, bool jarg2) { - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - bool arg2 ; - - arg1 = (Dali::RenderTask *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - (arg1)->SetCullMode(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) { - bool jresult ; - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - bool result; - - arg1 = (Dali::RenderTask *)jarg1; - { - try { - result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) { - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::RenderTask *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - (arg1)->SetRefreshRate(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) { - unsigned int jresult ; - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - unsigned int result; - - arg1 = (Dali::RenderTask *)jarg1; - { - try { - result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) { - bool jresult ; - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::Vector3 *arg2 = 0 ; - float *arg3 = 0 ; - float *arg4 = 0 ; - bool result; - - arg1 = (Dali::RenderTask *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - arg3 = (float *)jarg3; - arg4 = (float *)jarg4; - { - try { - result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) { - bool jresult ; - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::Actor arg2 ; - float arg3 ; - float arg4 ; - float *arg5 = 0 ; - float *arg6 = 0 ; - Dali::Actor *argp2 ; - bool result; - - arg1 = (Dali::RenderTask *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg2 = *argp2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - arg5 = (float *)jarg5; - arg6 = (float *)jarg6; - { - try { - result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) { - void * jresult ; - Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ; - Dali::RenderTask::RenderTaskSignalType *result = 0 ; - - arg1 = (Dali::RenderTask *)jarg1; - { - try { - result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) { - void * jresult ; - int arg1 ; - Dali::PointState::Type arg2 ; - float arg3 ; - float arg4 ; - Dali::TouchPoint *result = 0 ; - - arg1 = (int)jarg1; - arg2 = (Dali::PointState::Type)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - { - try { - result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) { - void * jresult ; - int arg1 ; - Dali::PointState::Type arg2 ; - float arg3 ; - float arg4 ; - float arg5 ; - float arg6 ; - Dali::TouchPoint *result = 0 ; - - arg1 = (int)jarg1; - arg2 = (Dali::PointState::Type)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - arg5 = (float)jarg5; - arg6 = (float)jarg6; - { - try { - result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) { - Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; - - arg1 = (Dali::TouchPoint *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) { - Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; - int arg2 ; - - arg1 = (Dali::TouchPoint *)jarg1; - arg2 = (int)jarg2; - if (arg1) (arg1)->deviceId = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) { - int jresult ; - Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; - int result; - - arg1 = (Dali::TouchPoint *)jarg1; - result = (int) ((arg1)->deviceId); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) { - Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; - Dali::PointState::Type arg2 ; - - arg1 = (Dali::TouchPoint *)jarg1; - arg2 = (Dali::PointState::Type)jarg2; - if (arg1) (arg1)->state = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) { - int jresult ; - Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; - Dali::PointState::Type result; - - arg1 = (Dali::TouchPoint *)jarg1; - result = (Dali::PointState::Type) ((arg1)->state); - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) { - Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; - Dali::Actor *arg2 = (Dali::Actor *) 0 ; - - arg1 = (Dali::TouchPoint *)jarg1; - arg2 = (Dali::Actor *)jarg2; - if (arg1) (arg1)->hitActor = *arg2; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) { - void * jresult ; - Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; - Dali::Actor *result = 0 ; - - arg1 = (Dali::TouchPoint *)jarg1; - result = (Dali::Actor *)& ((arg1)->hitActor); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) { - Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; - Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ; - - arg1 = (Dali::TouchPoint *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (arg1) (arg1)->local = *arg2; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) { - void * jresult ; - Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::TouchPoint *)jarg1; - result = (Dali::Vector2 *)& ((arg1)->local); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) { - Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; - Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ; - - arg1 = (Dali::TouchPoint *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (arg1) (arg1)->screen = *arg2; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) { - void * jresult ; - Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::TouchPoint *)jarg1; - result = (Dali::Vector2 *)& ((arg1)->screen); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() { - void * jresult ; - Dali::TouchEvent *result = 0 ; - - { - try { - result = (Dali::TouchEvent *)new Dali::TouchEvent(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) { - void * jresult ; - Dali::TouchEvent *arg1 = 0 ; - Dali::TouchEvent *result = 0 ; - - arg1 = (Dali::TouchEvent *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0); - return 0; - } - { - try { - result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) { - Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; - - arg1 = (Dali::TouchEvent *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; - Dali::TouchEvent *arg2 = 0 ; - Dali::TouchEvent *result = 0 ; - - arg1 = (Dali::TouchEvent *)jarg1; - arg2 = (Dali::TouchEvent *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0); - return 0; - } - { - try { - result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) { - unsigned long jresult ; - Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; - unsigned long result; - - arg1 = (Dali::TouchEvent *)jarg1; - { - try { - result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) { - unsigned long jresult ; - Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; - std::size_t result; - - arg1 = (Dali::TouchEvent *)jarg1; - { - try { - result = ((Dali::TouchEvent const *)arg1)->GetPointCount(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) { - int jresult ; - Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; - std::size_t arg2 ; - int32_t result; - - arg1 = (Dali::TouchEvent *)jarg1; - arg2 = (std::size_t)jarg2; - { - try { - result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) { - int jresult ; - Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; - std::size_t arg2 ; - Dali::PointState::Type result; - - arg1 = (Dali::TouchEvent *)jarg1; - arg2 = (std::size_t)jarg2; - { - try { - result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; - std::size_t arg2 ; - Dali::Actor result; - - arg1 = (Dali::TouchEvent *)jarg1; - arg2 = (std::size_t)jarg2; - { - try { - result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; - std::size_t arg2 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::TouchEvent *)jarg1; - arg2 = (std::size_t)jarg2; - { - try { - result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; - std::size_t arg2 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::TouchEvent *)jarg1; - arg2 = (std::size_t)jarg2; - { - try { - result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) { - float jresult ; - Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; - std::size_t arg2 ; - float result; - - arg1 = (Dali::TouchEvent *)jarg1; - arg2 = (std::size_t)jarg2; - { - try { - result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; - std::size_t arg2 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::TouchEvent *)jarg1; - arg2 = (std::size_t)jarg2; - { - try { - result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) { - float jresult ; - Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; - std::size_t arg2 ; - float result; - - arg1 = (Dali::TouchEvent *)jarg1; - arg2 = (std::size_t)jarg2; - { - try { - result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; - std::size_t arg2 ; - Dali::Degree result; - - arg1 = (Dali::TouchEvent *)jarg1; - arg2 = (std::size_t)jarg2; - { - try { - result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Degree((const Dali::Degree &)result); - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceClass(void * jarg1, unsigned long jarg2) { - int jresult ; - Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; - std::size_t arg2 ; - Dali::Device::Class::Type result; - - arg1 = (Dali::TouchEvent *)jarg1; - arg2 = (std::size_t)jarg2; - { - try { - result = ((Dali::TouchEvent const *)arg1)->GetDeviceClass(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceSubclass(void * jarg1, unsigned long jarg2) { - int jresult ; - Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; - std::size_t arg2 ; - Dali::Device::Subclass::Type result; - - arg1 = (Dali::TouchEvent *)jarg1; - arg2 = (std::size_t)jarg2; - { - try { - result = ((Dali::TouchEvent const *)arg1)->GetDeviceSubclass(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) { - int jresult ; - Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ; - std::size_t arg2 ; - Dali::MouseButton::Type result; - - arg1 = (Dali::TouchEvent *)jarg1; - arg2 = (std::size_t)jarg2; - { - try { - result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = static_cast< int >(result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() { - void * jresult ; - Dali::GestureDetector *result = 0 ; - - { - try { - result = (Dali::GestureDetector *)new Dali::GestureDetector(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::GestureDetector 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::GestureDetector::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) { - Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ; - - arg1 = (Dali::GestureDetector *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) { - void * jresult ; - Dali::GestureDetector *arg1 = 0 ; - Dali::GestureDetector *result = 0 ; - - arg1 = (Dali::GestureDetector *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0); - return 0; - } - { - try { - result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ; - Dali::GestureDetector *arg2 = 0 ; - Dali::GestureDetector *result = 0 ; - - arg1 = (Dali::GestureDetector *)jarg1; - arg2 = (Dali::GestureDetector *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0); - return 0; - } - { - try { - result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) { - Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::GestureDetector *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->Attach(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) { - Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::GestureDetector *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->Detach(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) { - Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ; - - arg1 = (Dali::GestureDetector *)jarg1; - { - try { - (arg1)->DetachAll(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) { - unsigned long jresult ; - Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ; - size_t result; - - arg1 = (Dali::GestureDetector *)jarg1; - { - try { - result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ; - size_t arg2 ; - Dali::Actor result; - - arg1 = (Dali::GestureDetector *)jarg1; - arg2 = (size_t)jarg2; - { - try { - result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) { - void * jresult ; - Dali::Gesture *arg1 = 0 ; - Dali::Gesture *result = 0 ; - - arg1 = (Dali::Gesture *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Gesture *arg1 = (Dali::Gesture *) 0 ; - Dali::Gesture *arg2 = 0 ; - Dali::Gesture *result = 0 ; - - arg1 = (Dali::Gesture *)jarg1; - arg2 = (Dali::Gesture *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) { - Dali::Gesture *arg1 = (Dali::Gesture *) 0 ; - - arg1 = (Dali::Gesture *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) { - int jresult ; - Dali::Gesture *arg1 = (Dali::Gesture *) 0 ; - Dali::GestureType::Value result; - - arg1 = (Dali::Gesture *)jarg1; - result = (Dali::GestureType::Value) ((arg1)->GetType()); - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) { - int jresult ; - Dali::Gesture *arg1 = (Dali::Gesture *) 0 ; - Dali::GestureState result; - - arg1 = (Dali::Gesture *)jarg1; - result = (Dali::GestureState) ((arg1)->GetState()); - jresult = (int)result; - return jresult; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) { - unsigned int jresult ; - Dali::Gesture *arg1 = (Dali::Gesture *) 0 ; - unsigned int result; - - arg1 = (Dali::Gesture *)jarg1; - result = (unsigned int) ((arg1)->GetTime()); - jresult = result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_sourceType_get(void * gesture) { - int jresult ; - Dali::Gesture *jGesture = (Dali::Gesture *) gesture; - Dali::GestureSourceType result; - - if (!jGesture) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0); - return 0; - } - { - try { - result = (Dali::GestureSourceType)jGesture->GetSourceType(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_sourceData_get(void * gesture) { - int jresult ; - Dali::Gesture *jGesture = (Dali::Gesture *) gesture; - Dali::GestureSourceData result; - - if (!jGesture) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::gesture const & type is null", 0); - return 0; - } - { - try { - result = (Dali::GestureSourceData)jGesture->GetSourceData(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() { - void * jresult ; - Dali::HoverEvent *result = 0 ; - - { - try { - result = (Dali::HoverEvent *)new Dali::HoverEvent(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) { - void * jresult ; - Dali::HoverEvent *arg1 = 0 ; - Dali::HoverEvent *result = 0 ; - - arg1 = (Dali::HoverEvent *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0); - return 0; - } - { - try { - result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) { - Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ; - - arg1 = (Dali::HoverEvent *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ; - Dali::HoverEvent *arg2 = 0 ; - Dali::HoverEvent *result = 0 ; - - arg1 = (Dali::HoverEvent *)jarg1; - arg2 = (Dali::HoverEvent *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0); - return 0; - } - { - try { - result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_New(unsigned int jarg1) { - void * jresult ; - unsigned int arg1 ; - Dali::HoverEvent result; - - arg1 = (unsigned int)jarg1; - { - try { - result = DevelHoverEvent::New(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::HoverEvent((const Dali::HoverEvent &)result); - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) { - unsigned long jresult ; - Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ; - unsigned long result; - - arg1 = (Dali::HoverEvent *)jarg1; - { - try { - result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) { - unsigned long jresult ; - Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ; - std::size_t result; - - arg1 = (Dali::HoverEvent *)jarg1; - { - try { - result = ((Dali::HoverEvent const *)arg1)->GetPointCount(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) { - int jresult ; - Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ; - std::size_t arg2 ; - int32_t result; - - arg1 = (Dali::HoverEvent *)jarg1; - arg2 = (std::size_t)jarg2; - { - try { - result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) { - int jresult ; - Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ; - std::size_t arg2 ; - Dali::PointState::Type result; - - arg1 = (Dali::HoverEvent *)jarg1; - arg2 = (std::size_t)jarg2; - { - try { - result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ; - std::size_t arg2 ; - Dali::Actor result; - - arg1 = (Dali::HoverEvent *)jarg1; - arg2 = (std::size_t)jarg2; - { - try { - result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ; - std::size_t arg2 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::HoverEvent *)jarg1; - arg2 = (std::size_t)jarg2; - { - try { - result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ; - std::size_t arg2 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::HoverEvent *)jarg1; - arg2 = (std::size_t)jarg2; - { - try { - result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() { - void * jresult ; - Dali::KeyEvent *result = 0 ; - - { - try { - result = (Dali::KeyEvent *)new Dali::KeyEvent(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(void * jarg1) { - void * jresult ; - Dali::KeyEvent *arg1 = 0 ; - Dali::KeyEvent *result = 0 ; - - arg1 = (Dali::KeyEvent *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0); - return 0; - } - { - try { - result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ; - Dali::KeyEvent *arg2 = 0 ; - Dali::KeyEvent *result = 0 ; - - arg1 = (Dali::KeyEvent *)jarg1; - arg2 = (Dali::KeyEvent *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0); - return 0; - } - { - try { - result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_New(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) { - void * jresult ; - std::string *arg1 = 0 ; - std::string *arg2 = 0 ; - int arg3 ; - int arg4 ; - unsigned long arg5 ; - Dali::KeyEvent::State *arg6 = 0 ; - Dali::KeyEvent::State temp6 ; - Dali::KeyEvent result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (int)jarg3; - arg4 = (int)jarg4; - arg5 = (unsigned long)jarg5; - temp6 = (Dali::KeyEvent::State)jarg6; - arg6 = &temp6; - { - try { - result = DevelKeyEvent::New((std::string const &)*arg1, "", (std::string const &)*arg2, arg3, arg4, arg5, (Dali::KeyEvent::State const &)*arg6, "", "", Device::Class::NONE, Device::Subclass::NONE); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result); - - //argout typemap for const std::string& - - - //argout typemap for const std::string& - - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) { - Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ; - - arg1 = (Dali::KeyEvent *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) { - bool jresult ; - Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ; - bool result; - - arg1 = (Dali::KeyEvent *)jarg1; - { - try { - result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) { - bool jresult ; - Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ; - bool result; - - arg1 = (Dali::KeyEvent *)jarg1; - { - try { - result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) { - bool jresult ; - Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ; - bool result; - - arg1 = (Dali::KeyEvent *)jarg1; - { - try { - result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) { - Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ; - std::string *arg2 = 0 ; - - argp1 = (Dali::KeyEvent *) jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0); - return ; - } - - Dali::KeyEvent arg1 = *argp1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - - { - try { - Dali::DevelKeyEvent::SetKeyName(arg1, (std::string const &)*arg2); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return ; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return ; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; - }; - } - } -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) { - char * jresult ; - - if( jarg1 == NULL ) - { - jresult = SWIG_csharp_string_callback( "" ); - } - else - { - Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0; - std::string *result = 0; - std::string str = ""; - - arg1 = ( Dali::KeyEvent * )jarg1; - { - try { - str = ((Dali::KeyEvent const *)arg1)->GetKeyName(); - result = (std::string *) &str; - jresult = SWIG_csharp_string_callback(result->c_str()); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - } - - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) { - Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ; - std::string *arg2 = 0 ; - - argp1 = (Dali::KeyEvent *) jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0); - return ; - } - - Dali::KeyEvent arg1 = *argp1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - - { - try { - Dali::DevelKeyEvent::SetKeyString(arg1, (std::string const &)*arg2); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return ; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return ; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; - }; - } - } -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) { - char * jresult ; - - Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0; - std::string *result = 0; - std::string str = ""; - arg1 = ( Dali::KeyEvent * )jarg1; - { - try { - str = ((Dali::KeyEvent const *)arg1)->GetKeyString(); - result = (std::string *) &str; - jresult = SWIG_csharp_string_callback(result->c_str()); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) { - Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ; - int arg2 ; - - argp1 = (Dali::KeyEvent *) jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0); - return ; - } - - Dali::KeyEvent arg1 = *argp1; - arg2 = (int)jarg2; - { - try { - Dali::DevelKeyEvent::SetKeyCode(arg1, arg2); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return ; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return ; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; - }; - } - } -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) { - int jresult ; - Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0; - int result; - - arg1 = (Dali::KeyEvent *)jarg1; - { - try { - result = (int)((Dali::KeyEvent const *)arg1)->GetKeyCode(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) { - Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ; - int arg2 ; - - argp1 = (Dali::KeyEvent *) jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0); - return ; - } - - Dali::KeyEvent arg1 = *argp1; - arg2 = (int)jarg2; - { - try { - Dali::DevelKeyEvent::SetKeyModifier(arg1, arg2); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return ; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return ; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; - }; - } - } -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) { - int jresult ; - Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0; - int result; - - arg1 = (Dali::KeyEvent *)jarg1; - { - try { - result = (int)((Dali::KeyEvent const *)arg1)->GetKeyModifier(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) { - Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ; - unsigned long arg2 ; - - argp1 = (Dali::KeyEvent *) jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0); - return ; - } - - Dali::KeyEvent arg1 = *argp1; - arg2 = (int)jarg2; - { - try { - Dali::DevelKeyEvent::SetTime(arg1, arg2); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return ; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return ; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; - }; - } - } -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) { - unsigned long jresult ; - Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0; - unsigned long result; - - arg1 = (Dali::KeyEvent *)jarg1; - { - try { - result = (int)((Dali::KeyEvent const *)arg1)->GetTime(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) { - Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0; - Dali::KeyEvent::State arg2; - - argp1 = (Dali::KeyEvent *) jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0); - return ; - } - - Dali::KeyEvent arg1 = *argp1; - arg2 = (Dali::KeyEvent::State)jarg2; - { - try { - Dali::DevelKeyEvent::SetState(arg1, arg2); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return ; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return ; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; - }; - } - } -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) { - int jresult ; - Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0; - Dali::KeyEvent::State result; - - arg1 = (Dali::KeyEvent *)jarg1; - { - try { - result = (Dali::KeyEvent::State)((Dali::KeyEvent const *)arg1)->GetState(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - jresult = (int)result; - return jresult; - -} - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) { - char * jresult ; - - Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0; - std::string *result = 0; - std::string str = ""; - - arg1 = ( Dali::KeyEvent * )jarg1; - { - try { - str = ((Dali::KeyEvent const *)arg1)->GetLogicalKey(); - result = (std::string *) &str; - jresult = SWIG_csharp_string_callback(result->c_str()); - } CALL_CATCH_EXCEPTION(0); - } - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() { - void * jresult ; - Dali::LongPressGestureDetector *result = 0 ; - - { - try { - result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() { - void * jresult ; - Dali::LongPressGestureDetector result; - - { - try { - result = Dali::LongPressGestureDetector::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) { - void * jresult ; - unsigned int arg1 ; - Dali::LongPressGestureDetector result; - - arg1 = (unsigned int)jarg1; - { - try { - result = Dali::LongPressGestureDetector::New(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) { - void * jresult ; - unsigned int arg1 ; - unsigned int arg2 ; - Dali::LongPressGestureDetector result; - - arg1 = (unsigned int)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = Dali::LongPressGestureDetector::New(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::LongPressGestureDetector 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::LongPressGestureDetector::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) { - Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ; - - arg1 = (Dali::LongPressGestureDetector *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) { - void * jresult ; - Dali::LongPressGestureDetector *arg1 = 0 ; - Dali::LongPressGestureDetector *result = 0 ; - - arg1 = (Dali::LongPressGestureDetector *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0); - return 0; - } - { - try { - result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ; - Dali::LongPressGestureDetector *arg2 = 0 ; - Dali::LongPressGestureDetector *result = 0 ; - - arg1 = (Dali::LongPressGestureDetector *)jarg1; - arg2 = (Dali::LongPressGestureDetector *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0); - return 0; - } - { - try { - result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) { - Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::LongPressGestureDetector *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - (arg1)->SetTouchesRequired(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) { - Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ; - unsigned int arg2 ; - unsigned int arg3 ; - - arg1 = (Dali::LongPressGestureDetector *)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (unsigned int)jarg3; - { - try { - (arg1)->SetTouchesRequired(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) { - unsigned int jresult ; - Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ; - unsigned int result; - - arg1 = (Dali::LongPressGestureDetector *)jarg1; - { - try { - result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) { - unsigned int jresult ; - Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ; - unsigned int result; - - arg1 = (Dali::LongPressGestureDetector *)jarg1; - { - try { - result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) { - void * jresult ; - Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ; - Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ; - - arg1 = (Dali::LongPressGestureDetector *)jarg1; - { - try { - result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0() { - void * jresult ; - Dali::LongPressGesture *result = 0 ; - - { - try { - result = (Dali::LongPressGesture *)new Dali::LongPressGesture(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_New(int jarg1) { - void * jresult ; - Dali::GestureState arg1 ; - Dali::LongPressGesture result; - - arg1 = (Dali::GestureState)jarg1; - { - try { - result = DevelLongPressGesture::New(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::LongPressGesture((const Dali::LongPressGesture &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) { - void * jresult ; - Dali::LongPressGesture *arg1 = 0 ; - Dali::LongPressGesture *result = 0 ; - - arg1 = (Dali::LongPressGesture *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0); - return 0; - } - { - try { - result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ; - Dali::LongPressGesture *arg2 = 0 ; - Dali::LongPressGesture *result = 0 ; - - arg1 = (Dali::LongPressGesture *)jarg1; - arg2 = (Dali::LongPressGesture *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0); - return 0; - } - { - try { - result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) { - Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ; - - arg1 = (Dali::LongPressGesture *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) { - unsigned int jresult ; - Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ; - unsigned int result; - - arg1 = (Dali::LongPressGesture *)jarg1; - result = (unsigned int) ((arg1)->GetNumberOfTouches()); - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) { - void * jresult ; - Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::LongPressGesture *)jarg1; - { - try { - result = ((Dali::LongPressGesture const *)arg1)->GetScreenPoint(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) { - void * jresult ; - Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::LongPressGesture *)jarg1; - { - try { - result = ((Dali::LongPressGesture const *)arg1)->GetLocalPoint(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() { - void * jresult ; - Dali::WheelEvent *result = 0 ; - - { - try { - result = (Dali::WheelEvent *)new Dali::WheelEvent(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) { - void * jresult ; - Dali::WheelEvent *arg1 = 0 ; - Dali::WheelEvent *result = 0 ; - - arg1 = (Dali::WheelEvent *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0); - return 0; - } - { - try { - result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; - Dali::WheelEvent *arg2 = 0 ; - Dali::WheelEvent *result = 0 ; - - arg1 = (Dali::WheelEvent *)jarg1; - arg2 = (Dali::WheelEvent *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0); - return 0; - } - { - try { - result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) { - void * jresult ; - Dali::WheelEvent::Type arg1 ; - int arg2 ; - unsigned int arg3 ; - Dali::Vector2 arg4 ; - int arg5 ; - unsigned int arg6 ; - Dali::Vector2 *argp4 ; - Dali::WheelEvent result; - - arg1 = (Dali::WheelEvent::Type)jarg1; - arg2 = (int)jarg2; - arg3 = (unsigned int)jarg3; - argp4 = (Dali::Vector2 *)jarg4; - if (!argp4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); - return 0; - } - arg4 = *argp4; - arg5 = (int)jarg5; - arg6 = (unsigned int)jarg6; - { - try { - result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) { - Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; - - arg1 = (Dali::WheelEvent *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) { - bool jresult ; - Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; - bool result; - - arg1 = (Dali::WheelEvent *)jarg1; - { - try { - result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) { - bool jresult ; - Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; - bool result; - - arg1 = (Dali::WheelEvent *)jarg1; - { - try { - result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) { - bool jresult ; - Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; - bool result; - - arg1 = (Dali::WheelEvent *)jarg1; - { - try { - result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) { - int jresult ; - Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; - Dali::WheelEvent::Type result; - - arg1 = (Dali::WheelEvent *)jarg1; - { - try { - result = ((Dali::WheelEvent const *)arg1)->GetType(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) { - int jresult ; - Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; - int result; - - arg1 = (Dali::WheelEvent *)jarg1; - { - try { - result = ((Dali::WheelEvent const *)arg1)->GetDirection(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) { - unsigned int jresult ; - Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; - unsigned int result; - - arg1 = (Dali::WheelEvent *)jarg1; - { - try { - result = ((Dali::WheelEvent const *)arg1)->GetModifiers(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) { - void * jresult ; - Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::WheelEvent *)jarg1; - { - try { - result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) { - int jresult ; - Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; - int result; - - arg1 = (Dali::WheelEvent *)jarg1; - { - try { - result = ((Dali::WheelEvent const *)arg1)->GetDelta(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) { - unsigned int jresult ; - Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ; - unsigned int result; - - arg1 = (Dali::WheelEvent *)jarg1; - { - try { - result = ((Dali::WheelEvent const *)arg1)->GetTime(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - - jresult = result; - return jresult; -} - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) { - char * jresult ; - Dali::KeyEvent *arg1 = 0 ; - std::string result; - - arg1 = (Dali::KeyEvent *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0); - return 0; - } - { - try { - result = arg1->GetDeviceName(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback((&result)->c_str()); - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) { - int jresult ; - Dali::KeyEvent *arg1 = 0 ; - Dali::Device::Class::Type result; - - arg1 = (Dali::KeyEvent *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Device::Class::Type)arg1->GetDeviceClass(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) { - int jresult ; - Dali::KeyEvent *arg1 = 0 ; - Dali::Device::Subclass::Type result; - - arg1 = (Dali::KeyEvent *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() { - void * jresult ; - Dali::Stage result; - - { - try { - result = Dali::Stage::GetCurrent(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Stage((const Dali::Stage &)result); - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() { - bool jresult ; - bool result; - - { - try { - result = (bool)Dali::Stage::IsInstalled(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) { - void * jresult ; - Dali::Stage *arg1 = (Dali::Stage *) 0 ; - Dali::RenderTaskList result; - - arg1 = (Dali::Stage *)jarg1; - { - try { - result = ((Dali::Stage const *)arg1)->GetRenderTaskList(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) { - void * jresult ; - Dali::Stage *arg1 = (Dali::Stage *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::Stage *)jarg1; - { - try { - result = ((Dali::Stage const *)arg1)->GetDpi(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) { - Dali::Stage *arg1 = (Dali::Stage *) 0 ; - float arg2 ; - - arg1 = (Dali::Stage *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->KeepRendering(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) { - void * jresult ; - Dali::Stage *arg1 = (Dali::Stage *) 0 ; - Dali::Stage::KeyEventSignalType *result = 0 ; - - arg1 = (Dali::Stage *)jarg1; - { - try { - result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) { - void * jresult ; - Dali::Stage *arg1 = (Dali::Stage *) 0 ; - Dali::Stage::EventProcessingFinishedSignalType *result = 0 ; - - arg1 = (Dali::Stage *)jarg1; - { - try { - result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) { - void * jresult ; - Dali::Stage *arg1 = (Dali::Stage *) 0 ; - Dali::Stage::TouchEventSignalType *result = 0 ; - - arg1 = (Dali::Stage *)jarg1; - { - try { - result = (Dali::Stage::TouchEventSignalType *) &(arg1)->TouchedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) { - void * jresult ; - Dali::Stage *arg1 = (Dali::Stage *) 0 ; - Dali::Stage::WheelEventSignalType *result = 0 ; - - arg1 = (Dali::Stage *)jarg1; - { - try { - result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) { - void * jresult ; - Dali::Stage *arg1 = (Dali::Stage *) 0 ; - Dali::Stage::ContextStatusSignal *result = 0 ; - - arg1 = (Dali::Stage *)jarg1; - { - try { - result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) { - void * jresult ; - Dali::Stage *arg1 = (Dali::Stage *) 0 ; - Dali::Stage::ContextStatusSignal *result = 0 ; - - arg1 = (Dali::Stage *)jarg1; - { - try { - result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) { - void * jresult ; - Dali::Stage *arg1 = (Dali::Stage *) 0 ; - Dali::Stage::SceneCreatedSignalType *result = 0 ; - - arg1 = (Dali::Stage *)jarg1; - { - try { - result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) { - Dali::Stage *arg1 = (Dali::Stage *) 0 ; - Dali::DevelStage::Rendering arg2 ; - - arg1 = (Dali::Stage *)jarg1; - arg2 = (Dali::DevelStage::Rendering)jarg2; - { - try { - DevelStage::SetRenderingBehavior(*arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) { - - int jresult ; - int result ; - Dali::Stage *arg1 = (Dali::Stage *) 0 ; - - arg1 = (Dali::Stage *)jarg1; - { - try { - result = (int)(DevelStage::GetRenderingBehavior(*arg1)); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) { - Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ; - - arg1 = (Dali::RelayoutContainer *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) { - Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ; - Dali::Actor *arg2 = 0 ; - Dali::Vector2 *arg3 = 0 ; - - arg1 = (Dali::RelayoutContainer *)jarg1; - arg2 = (Dali::Actor *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); - return ; - } - arg3 = (Dali::Vector2 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - { - try { - (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) { - void * jresult ; - Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; - Dali::CustomActor result; - - arg1 = (Dali::CustomActorImpl *)jarg1; - { - try { - result = ((Dali::CustomActorImpl const *)arg1)->Self(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::CustomActor((const Dali::CustomActor &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) { - Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; - int arg2 ; - - arg1 = (Dali::CustomActorImpl *)jarg1; - arg2 = (int)jarg2; - { - try { - (arg1)->OnSceneConnection(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) { - Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; - - arg1 = (Dali::CustomActorImpl *)jarg1; - { - try { - (arg1)->OnSceneDisconnection(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) { - Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; - Dali::Actor *arg2 = 0 ; - - arg1 = (Dali::CustomActorImpl *)jarg1; - arg2 = (Dali::Actor *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); - return ; - } - { - try { - (arg1)->OnChildAdd(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) { - Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; - Dali::Actor *arg2 = 0 ; - - arg1 = (Dali::CustomActorImpl *)jarg1; - arg2 = (Dali::Actor *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); - return ; - } - { - try { - (arg1)->OnChildRemove(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) { - Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; - Dali::Property::Index arg2 ; - Dali::Property::Value arg3 ; - Dali::Property::Value *argp3 ; - - arg1 = (Dali::CustomActorImpl *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - argp3 = (Dali::Property::Value *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); - return ; - } - arg3 = *argp3; - { - try { - (arg1)->OnPropertySet(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) { - Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; - Dali::Vector3 *arg2 = 0 ; - - arg1 = (Dali::CustomActorImpl *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - { - try { - (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) { - Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; - Dali::Animation *arg2 = 0 ; - Dali::Vector3 *arg3 = 0 ; - - arg1 = (Dali::CustomActorImpl *)jarg1; - arg2 = (Dali::Animation *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0); - return ; - } - arg3 = (Dali::Vector3 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - { - try { - (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) { - Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; - Dali::Vector2 *arg2 = 0 ; - Dali::RelayoutContainer *arg3 = 0 ; - - arg1 = (Dali::CustomActorImpl *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - arg3 = (Dali::RelayoutContainer *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0); - return ; - } - { - try { - (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) { - Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; - Dali::ResizePolicy::Type arg2 ; - Dali::Dimension::Type arg3 ; - - arg1 = (Dali::CustomActorImpl *)jarg1; - arg2 = (Dali::ResizePolicy::Type)jarg2; - arg3 = (Dali::Dimension::Type)jarg3; - { - try { - (arg1)->OnSetResizePolicy(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) { - void * jresult ; - Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; - Dali::Vector3 result; - - arg1 = (Dali::CustomActorImpl *)jarg1; - { - try { - result = (arg1)->GetNaturalSize(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) { - float jresult ; - Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; - Dali::Actor *arg2 = 0 ; - Dali::Dimension::Type arg3 ; - float result; - - arg1 = (Dali::CustomActorImpl *)jarg1; - arg2 = (Dali::Actor *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); - return 0; - } - arg3 = (Dali::Dimension::Type)jarg3; - { - try { - result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) { - float jresult ; - Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; - float arg2 ; - float result; - - arg1 = (Dali::CustomActorImpl *)jarg1; - arg2 = (float)jarg2; - { - try { - result = (float)(arg1)->GetHeightForWidth(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) { - float jresult ; - Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; - float arg2 ; - float result; - - arg1 = (Dali::CustomActorImpl *)jarg1; - arg2 = (float)jarg2; - { - try { - result = (float)(arg1)->GetWidthForHeight(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) { - bool jresult ; - Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; - Dali::Dimension::Type arg2 ; - bool result; - - arg1 = (Dali::CustomActorImpl *)jarg1; - arg2 = (Dali::Dimension::Type)jarg2; - { - try { - result = (bool)(arg1)->RelayoutDependentOnChildren(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) { - bool jresult ; - Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; - bool result; - - arg1 = (Dali::CustomActorImpl *)jarg1; - { - try { - result = (bool)(arg1)->RelayoutDependentOnChildren(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) { - Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; - Dali::Dimension::Type arg2 ; - - arg1 = (Dali::CustomActorImpl *)jarg1; - arg2 = (Dali::Dimension::Type)jarg2; - { - try { - (arg1)->OnCalculateRelayoutSize(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) { - Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; - float arg2 ; - Dali::Dimension::Type arg3 ; - - arg1 = (Dali::CustomActorImpl *)jarg1; - arg2 = (float)jarg2; - arg3 = (Dali::Dimension::Type)jarg3; - { - try { - (arg1)->OnLayoutNegotiated(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) { - bool jresult ; - Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ; - bool result; - - arg1 = (Dali::CustomActorImpl *)jarg1; - { - try { - result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() { - void * jresult ; - Dali::CustomActor *result = 0 ; - - { - try { - result = (Dali::CustomActor *)new Dali::CustomActor(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::CustomActor 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::CustomActor::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::CustomActor((const Dali::CustomActor &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) { - Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ; - - arg1 = (Dali::CustomActor *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) { - void * jresult ; - Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ; - Dali::CustomActorImpl *result = 0 ; - - arg1 = (Dali::CustomActor *)jarg1; - { - try { - result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) { - void * jresult ; - Dali::CustomActorImpl *arg1 = 0 ; - Dali::CustomActor *result = 0 ; - - arg1 = (Dali::CustomActorImpl *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0); - return 0; - } - { - try { - result = (Dali::CustomActor *)new Dali::CustomActor(*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) { - void * jresult ; - Dali::CustomActor *arg1 = 0 ; - Dali::CustomActor *result = 0 ; - - arg1 = (Dali::CustomActor *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0); - return 0; - } - { - try { - result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ; - Dali::CustomActor *arg2 = 0 ; - Dali::CustomActor *result = 0 ; - - arg1 = (Dali::CustomActor *)jarg1; - arg2 = (Dali::CustomActor *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0); - return 0; - } - { - try { - result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() { - int jresult ; - int result; - - result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() { - int jresult ; - int result; - - result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() { - int jresult ; - int result; - - result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() { - int jresult ; - int result; - - result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() { - int jresult ; - int result; - - result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() { - int jresult ; - int result; - - result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() { - int jresult ; - int result; - - result = (int)Dali::PanGestureDetector::Property::PANNING; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() { - void * jresult ; - Dali::PanGestureDetector::Property *result = 0 ; - - { - try { - result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) { - Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ; - - arg1 = (Dali::PanGestureDetector::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() { - void * jresult ; - Dali::Radian *result = 0 ; - - result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() { - void * jresult ; - Dali::Radian *result = 0 ; - - result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() { - void * jresult ; - Dali::Radian *result = 0 ; - - result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() { - void * jresult ; - Dali::Radian *result = 0 ; - - result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() { - void * jresult ; - Dali::Radian *result = 0 ; - - result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() { - void * jresult ; - Dali::Radian *result = 0 ; - - result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() { - void * jresult ; - Dali::Radian *result = 0 ; - - result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD; - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() { - void * jresult ; - Dali::PanGestureDetector *result = 0 ; - - { - try { - result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() { - void * jresult ; - Dali::PanGestureDetector result; - - { - try { - result = Dali::PanGestureDetector::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::PanGestureDetector 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::PanGestureDetector::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) { - Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; - - arg1 = (Dali::PanGestureDetector *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) { - void * jresult ; - Dali::PanGestureDetector *arg1 = 0 ; - Dali::PanGestureDetector *result = 0 ; - - arg1 = (Dali::PanGestureDetector *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0); - return 0; - } - { - try { - result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; - Dali::PanGestureDetector *arg2 = 0 ; - Dali::PanGestureDetector *result = 0 ; - - arg1 = (Dali::PanGestureDetector *)jarg1; - arg2 = (Dali::PanGestureDetector *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0); - return 0; - } - { - try { - result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) { - Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::PanGestureDetector *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - (arg1)->SetMinimumTouchesRequired(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) { - Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::PanGestureDetector *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - (arg1)->SetMaximumTouchesRequired(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumMotionEventAge(void * jarg1, unsigned int jarg2) { - Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; - uint32_t arg2 ; - - arg1 = (Dali::PanGestureDetector *)jarg1; - arg2 = (uint32_t)jarg2; - { - try { - (arg1)->SetMaximumMotionEventAge(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) { - unsigned int jresult ; - Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; - unsigned int result; - - arg1 = (Dali::PanGestureDetector *)jarg1; - { - try { - result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) { - unsigned int jresult ; - Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; - unsigned int result; - - arg1 = (Dali::PanGestureDetector *)jarg1; - { - try { - result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumMotionEventAge(void * jarg1) { - unsigned int jresult ; - Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; - uint32_t result; - - arg1 = (Dali::PanGestureDetector *)jarg1; - { - try { - result = (uint32_t)((Dali::PanGestureDetector const *)arg1)->GetMaximumMotionEventAge(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { - Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; - Dali::Radian arg2 ; - Dali::Radian arg3 ; - Dali::Radian *argp2 ; - Dali::Radian *argp3 ; - - arg1 = (Dali::PanGestureDetector *)jarg1; - argp2 = (Dali::Radian *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Radian *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return ; - } - arg3 = *argp3; - { - try { - (arg1)->AddAngle(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) { - Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; - Dali::Radian arg2 ; - Dali::Radian *argp2 ; - - arg1 = (Dali::PanGestureDetector *)jarg1; - argp2 = (Dali::Radian *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->AddAngle(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { - Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; - Dali::Radian arg2 ; - Dali::Radian arg3 ; - Dali::Radian *argp2 ; - Dali::Radian *argp3 ; - - arg1 = (Dali::PanGestureDetector *)jarg1; - argp2 = (Dali::Radian *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Radian *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return ; - } - arg3 = *argp3; - { - try { - (arg1)->AddDirection(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) { - Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; - Dali::Radian arg2 ; - Dali::Radian *argp2 ; - - arg1 = (Dali::PanGestureDetector *)jarg1; - argp2 = (Dali::Radian *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->AddDirection(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) { - unsigned long jresult ; - Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; - size_t result; - - arg1 = (Dali::PanGestureDetector *)jarg1; - { - try { - result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; - size_t arg2 ; - Dali::PanGestureDetector::AngleThresholdPair result; - - arg1 = (Dali::PanGestureDetector *)jarg1; - arg2 = (size_t)jarg2; - { - try { - result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) { - Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; - - arg1 = (Dali::PanGestureDetector *)jarg1; - { - try { - (arg1)->ClearAngles(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) { - Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; - Dali::Radian arg2 ; - Dali::Radian *argp2 ; - - arg1 = (Dali::PanGestureDetector *)jarg1; - argp2 = (Dali::Radian *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->RemoveAngle(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) { - Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; - Dali::Radian arg2 ; - Dali::Radian *argp2 ; - - arg1 = (Dali::PanGestureDetector *)jarg1; - argp2 = (Dali::Radian *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->RemoveDirection(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) { - void * jresult ; - Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ; - Dali::PanGestureDetector::DetectedSignalType *result = 0 ; - - arg1 = (Dali::PanGestureDetector *)jarg1; - { - try { - result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) { - Dali::PanGesture *arg1 = 0 ; - - arg1 = (Dali::PanGesture *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0); - return ; - } - { - try { - Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() { - void * jresult ; - Dali::PanGesture *result = 0 ; - - { - try { - result = (Dali::PanGesture *)new Dali::PanGesture(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_New(int jarg1) { - void * jresult ; - Dali::GestureState arg1 ; - Dali::PanGesture result; - - arg1 = (Dali::GestureState)jarg1; - { - try { - result = DevelPanGesture::New(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PanGesture((const Dali::PanGesture &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) { - void * jresult ; - Dali::PanGesture *arg1 = 0 ; - Dali::PanGesture *result = 0 ; - - arg1 = (Dali::PanGesture *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0); - return 0; - } - { - try { - result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; - Dali::PanGesture *arg2 = 0 ; - Dali::PanGesture *result = 0 ; - - arg1 = (Dali::PanGesture *)jarg1; - arg2 = (Dali::PanGesture *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0); - return 0; - } - { - try { - result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) { - Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; - - arg1 = (Dali::PanGesture *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) { - void * jresult ; - Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::PanGesture *)jarg1; - { - try { - result = ((Dali::PanGesture const *)arg1)->GetVelocity(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) { - void * jresult ; - Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::PanGesture *)jarg1; - { - try { - result = ((Dali::PanGesture const *)arg1)->GetDisplacement(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) { - void * jresult ; - Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::PanGesture *)jarg1; - { - try { - result = ((Dali::PanGesture const *)arg1)->GetPosition(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) { - void * jresult ; - Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::PanGesture *)jarg1; - { - try { - result = ((Dali::PanGesture const *)arg1)->GetScreenVelocity(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) { - void * jresult ; - Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::PanGesture *)jarg1; - { - try { - result = ((Dali::PanGesture const *)arg1)->GetScreenDisplacement(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) { - void * jresult ; - Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::PanGesture *)jarg1; - { - try { - result = ((Dali::PanGesture const *)arg1)->GetScreenPosition(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) { - unsigned int jresult ; - Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; - unsigned int result; - - arg1 = (Dali::PanGesture *)jarg1; - result = (unsigned int) ((arg1)->GetNumberOfTouches()); - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) { - float jresult ; - Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; - float result; - - arg1 = (Dali::PanGesture *)jarg1; - { - try { - result = (float)((Dali::PanGesture const *)arg1)->GetSpeed(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) { - float jresult ; - Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; - float result; - - arg1 = (Dali::PanGesture *)jarg1; - { - try { - result = (float)((Dali::PanGesture const *)arg1)->GetDistance(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) { - float jresult ; - Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; - float result; - - arg1 = (Dali::PanGesture *)jarg1; - { - try { - result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) { - float jresult ; - Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ; - float result; - - arg1 = (Dali::PanGesture *)jarg1; - { - try { - result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() { - void * jresult ; - Dali::PinchGestureDetector *result = 0 ; - - { - try { - result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() { - void * jresult ; - Dali::PinchGestureDetector result; - - { - try { - result = Dali::PinchGestureDetector::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::PinchGestureDetector 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::PinchGestureDetector::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) { - Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ; - - arg1 = (Dali::PinchGestureDetector *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) { - void * jresult ; - Dali::PinchGestureDetector *arg1 = 0 ; - Dali::PinchGestureDetector *result = 0 ; - - arg1 = (Dali::PinchGestureDetector *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0); - return 0; - } - { - try { - result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ; - Dali::PinchGestureDetector *arg2 = 0 ; - Dali::PinchGestureDetector *result = 0 ; - - arg1 = (Dali::PinchGestureDetector *)jarg1; - arg2 = (Dali::PinchGestureDetector *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0); - return 0; - } - { - try { - result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) { - void * jresult ; - Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ; - Dali::PinchGestureDetector::DetectedSignalType *result = 0 ; - - arg1 = (Dali::PinchGestureDetector *)jarg1; - { - try { - result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0() { - void * jresult ; - Dali::PinchGesture *result = 0 ; - - { - try { - result = (Dali::PinchGesture *)new Dali::PinchGesture(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_New(int jarg1) { - void * jresult ; - Dali::GestureState arg1 ; - Dali::PinchGesture result; - - arg1 = (Dali::GestureState)jarg1; - { - try { - result = DevelPinchGesture::New(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PinchGesture((const Dali::PinchGesture &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) { - void * jresult ; - Dali::PinchGesture *arg1 = 0 ; - Dali::PinchGesture *result = 0 ; - - arg1 = (Dali::PinchGesture *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0); - return 0; - } - { - try { - result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ; - Dali::PinchGesture *arg2 = 0 ; - Dali::PinchGesture *result = 0 ; - - arg1 = (Dali::PinchGesture *)jarg1; - arg2 = (Dali::PinchGesture *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0); - return 0; - } - { - try { - result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) { - Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ; - - arg1 = (Dali::PinchGesture *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) { - float jresult ; - Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ; - float result; - - arg1 = (Dali::PinchGesture *)jarg1; - result = (float) ((arg1)->GetScale()); - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) { - float jresult ; - Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ; - float result; - - arg1 = (Dali::PinchGesture *)jarg1; - result = (float) ((arg1)->GetSpeed()); - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) { - void * jresult ; - Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::PinchGesture *)jarg1; - { - try { - result = ((Dali::PinchGesture const *)arg1)->GetScreenCenterPoint(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) { - void * jresult ; - Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::PinchGesture *)jarg1; - { - try { - result = ((Dali::PinchGesture const *)arg1)->GetLocalCenterPoint(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() { - void * jresult ; - Dali::TapGestureDetector *result = 0 ; - - { - try { - result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() { - void * jresult ; - Dali::TapGestureDetector result; - - { - try { - result = Dali::TapGestureDetector::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) { - void * jresult ; - unsigned int arg1 ; - Dali::TapGestureDetector result; - - arg1 = (unsigned int)jarg1; - { - try { - result = Dali::TapGestureDetector::New(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::TapGestureDetector 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::TapGestureDetector::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) { - Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ; - - arg1 = (Dali::TapGestureDetector *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) { - void * jresult ; - Dali::TapGestureDetector *arg1 = 0 ; - Dali::TapGestureDetector *result = 0 ; - - arg1 = (Dali::TapGestureDetector *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0); - return 0; - } - { - try { - result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ; - Dali::TapGestureDetector *arg2 = 0 ; - Dali::TapGestureDetector *result = 0 ; - - arg1 = (Dali::TapGestureDetector *)jarg1; - arg2 = (Dali::TapGestureDetector *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0); - return 0; - } - { - try { - result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) { - Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::TapGestureDetector *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - (arg1)->SetMinimumTapsRequired(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) { - Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::TapGestureDetector *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - (arg1)->SetMaximumTapsRequired(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) { - unsigned int jresult ; - Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ; - unsigned int result; - - arg1 = (Dali::TapGestureDetector *)jarg1; - { - try { - result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) { - unsigned int jresult ; - Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ; - unsigned int result; - - arg1 = (Dali::TapGestureDetector *)jarg1; - { - try { - result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_ReceiveAllTapEvents(void * tapGestureDetector, bool isReceive) { - Dali::TapGestureDetector *detector = (Dali::TapGestureDetector *) 0 ; - - detector = (Dali::TapGestureDetector *)tapGestureDetector; - if (!detector) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0); - return; - } - { - try { - (detector)->ReceiveAllTapEvents(isReceive); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) { - void * jresult ; - Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ; - Dali::TapGestureDetector::DetectedSignalType *result = 0 ; - - arg1 = (Dali::TapGestureDetector *)jarg1; - { - try { - result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() { - void * jresult ; - Dali::TapGesture *result = 0 ; - - { - try { - result = (Dali::TapGesture *)new Dali::TapGesture(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_New(int jarg1) { - void * jresult ; - Dali::GestureState arg1 ; - Dali::TapGesture result; - - arg1 = (Dali::GestureState)jarg1; - { - try { - result = DevelTapGesture::New(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::TapGesture((const Dali::TapGesture &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) { - void * jresult ; - Dali::TapGesture *arg1 = 0 ; - Dali::TapGesture *result = 0 ; - - arg1 = (Dali::TapGesture *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0); - return 0; - } - { - try { - result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ; - Dali::TapGesture *arg2 = 0 ; - Dali::TapGesture *result = 0 ; - - arg1 = (Dali::TapGesture *)jarg1; - arg2 = (Dali::TapGesture *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0); - return 0; - } - { - try { - result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) { - Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ; - - arg1 = (Dali::TapGesture *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) { - unsigned int jresult ; - Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ; - unsigned int result; - - arg1 = (Dali::TapGesture *)jarg1; - result = (unsigned int) ((arg1)->GetNumberOfTaps()); - jresult = result; - return jresult; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) { - unsigned int jresult ; - Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ; - unsigned int result; - - arg1 = (Dali::TapGesture *)jarg1; - result = (unsigned int) ((arg1)->GetNumberOfTouches()); - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) { - void * jresult ; - Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::TapGesture *)jarg1; - { - try { - result = ((Dali::TapGesture const *)arg1)->GetScreenPoint(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) { - void * jresult ; - Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::TapGesture *)jarg1; - { - try { - result = ((Dali::TapGesture const *)arg1)->GetLocalPoint(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() { - void * jresult ; - Dali::AlphaFunction *result = 0 ; - - { - try { - result = (Dali::AlphaFunction *)new Dali::AlphaFunction(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) { - void * jresult ; - Dali::AlphaFunction::BuiltinFunction arg1 ; - Dali::AlphaFunction *result = 0 ; - - arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1; - { - try { - result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) { - void * jresult ; - Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ; - Dali::AlphaFunction *result = 0 ; - - arg1 = (Dali::AlphaFunctionPrototype)jarg1; - { - try { - result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector2 *arg1 = 0 ; - Dali::Vector2 *arg2 = 0 ; - Dali::AlphaFunction *result = 0 ; - - arg1 = (Dali::Vector2 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) { - void * jresult ; - Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ; - Dali::Vector4 result; - - arg1 = (Dali::AlphaFunction *)jarg1; - { - try { - result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) { - void * jresult ; - Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ; - Dali::AlphaFunctionPrototype result; - - arg1 = (Dali::AlphaFunction *)jarg1; - { - try { - result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) { - int jresult ; - Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ; - Dali::AlphaFunction::BuiltinFunction result; - - arg1 = (Dali::AlphaFunction *)jarg1; - { - try { - result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) { - int jresult ; - Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ; - Dali::AlphaFunction::Mode result; - - arg1 = (Dali::AlphaFunction *)jarg1; - { - try { - result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) { - Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ; - - arg1 = (Dali::AlphaFunction *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() { - void * jresult ; - Dali::KeyFrames result; - - { - try { - result = Dali::KeyFrames::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::KeyFrames 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::KeyFrames::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() { - void * jresult ; - Dali::KeyFrames *result = 0 ; - - { - try { - result = (Dali::KeyFrames *)new Dali::KeyFrames(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) { - Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ; - - arg1 = (Dali::KeyFrames *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) { - void * jresult ; - Dali::KeyFrames *arg1 = 0 ; - Dali::KeyFrames *result = 0 ; - - arg1 = (Dali::KeyFrames *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0); - return 0; - } - { - try { - result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ; - Dali::KeyFrames *arg2 = 0 ; - Dali::KeyFrames *result = 0 ; - - arg1 = (Dali::KeyFrames *)jarg1; - arg2 = (Dali::KeyFrames *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0); - return 0; - } - { - try { - result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) { - int jresult ; - Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ; - Dali::Property::Type result; - - arg1 = (Dali::KeyFrames *)jarg1; - { - try { - result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) { - Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ; - float arg2 ; - Dali::Property::Value arg3 ; - Dali::Property::Value *argp3 ; - - arg1 = (Dali::KeyFrames *)jarg1; - arg2 = (float)jarg2; - argp3 = (Dali::Property::Value *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); - return ; - } - arg3 = *argp3; - { - try { - (arg1)->Add(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) { - Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ; - float arg2 ; - Dali::Property::Value arg3 ; - Dali::AlphaFunction arg4 ; - Dali::Property::Value *argp3 ; - Dali::AlphaFunction *argp4 ; - - arg1 = (Dali::KeyFrames *)jarg1; - arg2 = (float)jarg2; - argp3 = (Dali::Property::Value *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); - return ; - } - arg3 = *argp3; - argp4 = (Dali::AlphaFunction *)jarg4; - if (!argp4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); - return ; - } - arg4 = *argp4; - { - try { - (arg1)->Add(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrameCount(void* keyFrames) -{ - unsigned int jresult; - { - try { - jresult = Dali::DevelKeyFrames::GetKeyFrameCount(*((Dali::KeyFrames*)keyFrames)); - } CALL_CATCH_EXCEPTION(0); - } - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrame(void* keyFrames, unsigned int index, float* time, void* value) -{ - if (!value) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); - return ; - } - try { - Dali::DevelKeyFrames::GetKeyFrame(*((Dali::KeyFrames*)keyFrames), (size_t)index, *time, *((Property::Value*)value)); - } CALL_CATCH_EXCEPTION(); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_SetKeyFrameValue(void* keyFrames, unsigned int index, void* value) -{ - if (!value) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); - return ; - } - try { - Dali::DevelKeyFrames::SetKeyFrameValue(*((Dali::KeyFrames*)keyFrames), (size_t)index, *((const Property::Value*)value)); - } CALL_CATCH_EXCEPTION(); -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() { - int jresult ; - int result; - - result = (int)Dali::Path::Property::POINTS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() { - int jresult ; - int result; - - result = (int)Dali::Path::Property::CONTROL_POINTS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() { - void * jresult ; - Dali::Path::Property *result = 0 ; - - { - try { - result = (Dali::Path::Property *)new Dali::Path::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) { - Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ; - - arg1 = (Dali::Path::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() { - void * jresult ; - Dali::Path result; - - { - try { - result = Dali::Path::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Path((const Dali::Path &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Path 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::Path::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Path((const Dali::Path &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() { - void * jresult ; - Dali::Path *result = 0 ; - - { - try { - result = (Dali::Path *)new Dali::Path(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) { - Dali::Path *arg1 = (Dali::Path *) 0 ; - - arg1 = (Dali::Path *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Path *arg1 = 0 ; - Dali::Path *result = 0 ; - - arg1 = (Dali::Path *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Path *arg1 = (Dali::Path *) 0 ; - Dali::Path *arg2 = 0 ; - Dali::Path *result = 0 ; - - arg1 = (Dali::Path *)jarg1; - arg2 = (Dali::Path *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) { - Dali::Path *arg1 = (Dali::Path *) 0 ; - Dali::Vector3 *arg2 = 0 ; - - arg1 = (Dali::Path *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - { - try { - (arg1)->AddPoint((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) { - Dali::Path *arg1 = (Dali::Path *) 0 ; - Dali::Vector3 *arg2 = 0 ; - - arg1 = (Dali::Path *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - { - try { - (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) { - Dali::Path *arg1 = (Dali::Path *) 0 ; - float arg2 ; - - arg1 = (Dali::Path *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->GenerateControlPoints(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) { - Dali::Path *arg1 = (Dali::Path *) 0 ; - float arg2 ; - Dali::Vector3 *arg3 = 0 ; - Dali::Vector3 *arg4 = 0 ; - - arg1 = (Dali::Path *)jarg1; - arg2 = (float)jarg2; - arg3 = (Dali::Vector3 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); - return ; - } - arg4 = (Dali::Vector3 *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); - return ; - } - { - try { - ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::Path *arg1 = (Dali::Path *) 0 ; - size_t arg2 ; - Dali::Vector3 *result = 0 ; - - arg1 = (Dali::Path *)jarg1; - arg2 = (size_t)jarg2; - { - try { - result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::Path *arg1 = (Dali::Path *) 0 ; - size_t arg2 ; - Dali::Vector3 *result = 0 ; - - arg1 = (Dali::Path *)jarg1; - arg2 = (size_t)jarg2; - { - try { - result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) { - unsigned long jresult ; - Dali::Path *arg1 = (Dali::Path *) 0 ; - size_t result; - - arg1 = (Dali::Path *)jarg1; - { - try { - result = ((Dali::Path const *)arg1)->GetPointCount(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) { - void * jresult ; - float arg1 ; - Dali::TimePeriod *result = 0 ; - - arg1 = (float)jarg1; - { - try { - result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) { - void * jresult ; - float arg1 ; - float arg2 ; - Dali::TimePeriod *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - { - try { - result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) { - Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ; - - arg1 = (Dali::TimePeriod *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) { - Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ; - float arg2 ; - - arg1 = (Dali::TimePeriod *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->delaySeconds = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) { - float jresult ; - Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ; - float result; - - arg1 = (Dali::TimePeriod *)jarg1; - result = (float) ((arg1)->delaySeconds); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) { - Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ; - float arg2 ; - - arg1 = (Dali::TimePeriod *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->durationSeconds = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) { - float jresult ; - Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ; - float result; - - arg1 = (Dali::TimePeriod *)jarg1; - result = (float) ((arg1)->durationSeconds); - jresult = result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() { - int jresult ; - int result; - - result = (int)Dali::LinearConstrainer::Property::VALUE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() { - int jresult ; - int result; - - result = (int)Dali::LinearConstrainer::Property::PROGRESS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() { - void * jresult ; - Dali::LinearConstrainer::Property *result = 0 ; - - { - try { - result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) { - Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ; - - arg1 = (Dali::LinearConstrainer::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() { - void * jresult ; - Dali::LinearConstrainer result; - - { - try { - result = Dali::LinearConstrainer::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::LinearConstrainer 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::LinearConstrainer::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() { - void * jresult ; - Dali::LinearConstrainer *result = 0 ; - - { - try { - result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) { - Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ; - - arg1 = (Dali::LinearConstrainer *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) { - void * jresult ; - Dali::LinearConstrainer *arg1 = 0 ; - Dali::LinearConstrainer *result = 0 ; - - arg1 = (Dali::LinearConstrainer *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0); - return 0; - } - { - try { - result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ; - Dali::LinearConstrainer *arg2 = 0 ; - Dali::LinearConstrainer *result = 0 ; - - arg1 = (Dali::LinearConstrainer *)jarg1; - arg2 = (Dali::LinearConstrainer *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0); - return 0; - } - { - try { - result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) { - Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - SwigValueWrapper< Dali::Property > arg3 ; - Dali::Vector2 *arg4 = 0 ; - Dali::Vector2 *arg5 = 0 ; - Dali::Property *argp2 ; - Dali::Property *argp3 ; - - arg1 = (Dali::LinearConstrainer *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Property *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg3 = *argp3; - arg4 = (Dali::Vector2 *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - arg5 = (Dali::Vector2 *)jarg5; - if (!arg5) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - { - try { - (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { - Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - SwigValueWrapper< Dali::Property > arg3 ; - Dali::Vector2 *arg4 = 0 ; - Dali::Property *argp2 ; - Dali::Property *argp3 ; - - arg1 = (Dali::LinearConstrainer *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Property *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg3 = *argp3; - arg4 = (Dali::Vector2 *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - { - try { - (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) { - Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ; - Dali::Handle *arg2 = 0 ; - - arg1 = (Dali::LinearConstrainer *)jarg1; - arg2 = (Dali::Handle *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); - return ; - } - { - try { - (arg1)->Remove(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() { - int jresult ; - int result; - - result = (int)Dali::PathConstrainer::Property::FORWARD; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() { - int jresult ; - int result; - - result = (int)Dali::PathConstrainer::Property::POINTS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() { - int jresult ; - int result; - - result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() { - void * jresult ; - Dali::PathConstrainer::Property *result = 0 ; - - { - try { - result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) { - Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ; - - arg1 = (Dali::PathConstrainer::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() { - void * jresult ; - Dali::PathConstrainer result; - - { - try { - result = Dali::PathConstrainer::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::PathConstrainer 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::PathConstrainer::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() { - void * jresult ; - Dali::PathConstrainer *result = 0 ; - - { - try { - result = (Dali::PathConstrainer *)new Dali::PathConstrainer(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) { - Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ; - - arg1 = (Dali::PathConstrainer *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) { - void * jresult ; - Dali::PathConstrainer *arg1 = 0 ; - Dali::PathConstrainer *result = 0 ; - - arg1 = (Dali::PathConstrainer *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0); - return 0; - } - { - try { - result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ; - Dali::PathConstrainer *arg2 = 0 ; - Dali::PathConstrainer *result = 0 ; - - arg1 = (Dali::PathConstrainer *)jarg1; - arg2 = (Dali::PathConstrainer *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0); - return 0; - } - { - try { - result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) { - Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - SwigValueWrapper< Dali::Property > arg3 ; - Dali::Vector2 *arg4 = 0 ; - Dali::Vector2 *arg5 = 0 ; - Dali::Property *argp2 ; - Dali::Property *argp3 ; - - arg1 = (Dali::PathConstrainer *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Property *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg3 = *argp3; - arg4 = (Dali::Vector2 *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - arg5 = (Dali::Vector2 *)jarg5; - if (!arg5) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - { - try { - (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { - Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ; - SwigValueWrapper< Dali::Property > arg2 ; - SwigValueWrapper< Dali::Property > arg3 ; - Dali::Vector2 *arg4 = 0 ; - Dali::Property *argp2 ; - Dali::Property *argp3 ; - - arg1 = (Dali::PathConstrainer *)jarg1; - argp2 = (Dali::Property *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Property *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0); - return ; - } - arg3 = *argp3; - arg4 = (Dali::Vector2 *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - { - try { - (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) { - Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ; - Dali::Handle *arg2 = 0 ; - - arg1 = (Dali::PathConstrainer *)jarg1; - arg2 = (Dali::Handle *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); - return ; - } - { - try { - (arg1)->Remove(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() { - int jresult ; - Dali::FittingMode::Type result; - - result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() { - int jresult ; - Dali::SamplingMode::Type result; - - result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) { - bool jresult ; - Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ; - bool result; - - arg1 = (Dali::NativeImageInterface *)jarg1; - { - try { - result = (bool)(arg1)->CreateResource(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) { - Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ; - - arg1 = (Dali::NativeImageInterface *)jarg1; - { - try { - (arg1)->DestroyResource(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) { - unsigned int jresult ; - Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ; - unsigned int result; - - arg1 = (Dali::NativeImageInterface *)jarg1; - { - try { - result = (unsigned int)(arg1)->TargetTexture(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) { - Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ; - - arg1 = (Dali::NativeImageInterface *)jarg1; - { - try { - (arg1)->PrepareTexture(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) { - unsigned int jresult ; - Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ; - unsigned int result; - - arg1 = (Dali::NativeImageInterface *)jarg1; - { - try { - result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) { - unsigned int jresult ; - Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ; - unsigned int result; - - arg1 = (Dali::NativeImageInterface *)jarg1; - { - try { - result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) { - bool jresult ; - Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ; - bool result; - - arg1 = (Dali::NativeImageInterface *)jarg1; - { - try { - result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() { - int jresult ; - int result; - - result = (int)Dali::CameraActor::Property::TYPE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() { - int jresult ; - int result; - - result = (int)Dali::CameraActor::Property::PROJECTION_MODE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() { - int jresult ; - int result; - - result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() { - int jresult ; - int result; - - result = (int)Dali::CameraActor::Property::ASPECT_RATIO; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() { - int jresult ; - int result; - - result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() { - int jresult ; - int result; - - result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() { - int jresult ; - int result; - - result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() { - int jresult ; - int result; - - result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() { - int jresult ; - int result; - - result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() { - int jresult ; - int result; - - result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() { - int jresult ; - int result; - - result = (int)Dali::CameraActor::Property::TARGET_POSITION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() { - int jresult ; - int result; - - result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() { - int jresult ; - int result; - - result = (int)Dali::CameraActor::Property::VIEW_MATRIX; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() { - int jresult ; - int result; - - result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ORTHOGRAPHIC_SIZE_get() { - int jresult ; - int result; - - result = (int)Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_DIRECTION_get() { - int jresult ; - int result; - - result = (int)Dali::DevelCameraActor::Property::PROJECTION_DIRECTION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() { - void * jresult ; - Dali::CameraActor::Property *result = 0 ; - - { - try { - result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) { - Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ; - - arg1 = (Dali::CameraActor::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() { - void * jresult ; - Dali::CameraActor *result = 0 ; - - { - try { - result = (Dali::CameraActor *)new Dali::CameraActor(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() { - void * jresult ; - Dali::CameraActor result; - - { - try { - result = Dali::CameraActor::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::CameraActor((const Dali::CameraActor &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Size *arg1 = 0 ; - Dali::CameraActor result; - - arg1 = (Dali::Size *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0); - return 0; - } - { - try { - result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::CameraActor((const Dali::CameraActor &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New3DCamera() { - void * jresult ; - Dali::CameraActor result; - - { - try { - result = Dali::CameraActor::New3DCamera(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::CameraActor((const Dali::CameraActor &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::CameraActor 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::CameraActor::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::CameraActor((const Dali::CameraActor &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) { - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - - arg1 = (Dali::CameraActor *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) { - void * jresult ; - Dali::CameraActor *arg1 = 0 ; - Dali::CameraActor *result = 0 ; - - arg1 = (Dali::CameraActor *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0); - return 0; - } - { - try { - result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - Dali::CameraActor *arg2 = 0 ; - Dali::CameraActor *result = 0 ; - - arg1 = (Dali::CameraActor *)jarg1; - arg2 = (Dali::CameraActor *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0); - return 0; - } - { - try { - result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) { - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - Dali::Camera::Type arg2 ; - - arg1 = (Dali::CameraActor *)jarg1; - arg2 = (Dali::Camera::Type)jarg2; - { - try { - (arg1)->SetType(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) { - int jresult ; - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - Dali::Camera::Type result; - - arg1 = (Dali::CameraActor *)jarg1; - { - try { - result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) { - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - Dali::Camera::ProjectionMode arg2 ; - - arg1 = (Dali::CameraActor *)jarg1; - arg2 = (Dali::Camera::ProjectionMode)jarg2; - { - try { - (arg1)->SetProjectionMode(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) { - int jresult ; - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - Dali::Camera::ProjectionMode result; - - arg1 = (Dali::CameraActor *)jarg1; - { - try { - result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) { - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - float arg2 ; - - arg1 = (Dali::CameraActor *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetFieldOfView(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) { - float jresult ; - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - float result; - - arg1 = (Dali::CameraActor *)jarg1; - { - try { - result = (float)(arg1)->GetFieldOfView(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) { - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - float arg2 ; - - arg1 = (Dali::CameraActor *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetAspectRatio(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) { - float jresult ; - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - float result; - - arg1 = (Dali::CameraActor *)jarg1; - { - try { - result = (float)(arg1)->GetAspectRatio(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) { - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - float arg2 ; - - arg1 = (Dali::CameraActor *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetNearClippingPlane(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) { - float jresult ; - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - float result; - - arg1 = (Dali::CameraActor *)jarg1; - { - try { - result = (float)(arg1)->GetNearClippingPlane(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) { - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - float arg2 ; - - arg1 = (Dali::CameraActor *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetFarClippingPlane(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) { - float jresult ; - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - float result; - - arg1 = (Dali::CameraActor *)jarg1; - { - try { - result = (float)(arg1)->GetFarClippingPlane(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) { - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - Dali::Vector3 *arg2 = 0 ; - - arg1 = (Dali::CameraActor *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) { - void * jresult ; - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - Dali::Vector3 result; - - arg1 = (Dali::CameraActor *)jarg1; - { - try { - result = ((Dali::CameraActor const *)arg1)->GetTargetPosition(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, bool jarg2) { - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - bool arg2 ; - - arg1 = (Dali::CameraActor *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - (arg1)->SetInvertYAxis(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) { - bool jresult ; - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - bool result; - - arg1 = (Dali::CameraActor *)jarg1; - { - try { - result = (bool)(arg1)->GetInvertYAxis(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) { - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - Dali::Size *arg2 = 0 ; - - arg1 = (Dali::CameraActor *)jarg1; - arg2 = (Dali::Size *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0); - return ; - } - { - try { - (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) { - Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ; - Dali::Size *arg2 = 0 ; - - arg1 = (Dali::CameraActor *)jarg1; - arg2 = (Dali::Size *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0); - return ; - } - { - try { - (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() { - void * jresult ; - std::pair< std::string,Dali::Property::Value > *result = 0 ; - - { - try { - result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) { - void * jresult ; - std::string arg1 ; - Dali::Property::Value arg2 ; - Dali::Property::Value *argp2 ; - std::pair< std::string,Dali::Property::Value > *result = 0 ; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - (&arg1)->assign(jarg1); - argp2 = (Dali::Property::Value *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) { - void * jresult ; - std::pair< std::string,Dali::Property::Value > *arg1 = 0 ; - std::pair< std::string,Dali::Property::Value > *result = 0 ; - - arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0); - return 0; - } - { - try { - result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >((std::pair< std::string,Dali::Property::Value > const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) { - std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - if (arg1) (arg1)->first = *arg2; - - //argout typemap for const std::string& - -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) { - char * jresult ; - std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ; - std::string *result = 0 ; - - arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1; - result = (std::string *) & ((arg1)->first); - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) { - std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ; - Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ; - - arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1; - arg2 = (Dali::Property::Value *)jarg2; - if (arg1) (arg1)->second = *arg2; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) { - void * jresult ; - std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ; - Dali::Property::Value *result = 0 ; - - arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1; - result = (Dali::Property::Value *)& ((arg1)->second); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) { - std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ; - - arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) { - std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; - - arg1 = (std::vector< Dali::TouchPoint > *)jarg1; - { - try { - (arg1)->clear(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) { - std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; - Dali::TouchPoint *arg2 = 0 ; - - arg1 = (std::vector< Dali::TouchPoint > *)jarg1; - arg2 = (Dali::TouchPoint *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0); - return ; - } - { - try { - (arg1)->push_back((Dali::TouchPoint const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) { - unsigned long jresult ; - std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; - std::vector< Dali::TouchPoint >::size_type result; - - arg1 = (std::vector< Dali::TouchPoint > *)jarg1; - { - try { - result = ((std::vector< Dali::TouchPoint > const *)arg1)->size(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) { - unsigned long jresult ; - std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; - std::vector< Dali::TouchPoint >::size_type result; - - arg1 = (std::vector< Dali::TouchPoint > *)jarg1; - { - try { - result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) { - std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; - std::vector< Dali::TouchPoint >::size_type arg2 ; - - arg1 = (std::vector< Dali::TouchPoint > *)jarg1; - arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2; - { - try { - (arg1)->reserve(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() { - void * jresult ; - std::vector< Dali::TouchPoint > *result = 0 ; - - { - try { - result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) { - void * jresult ; - std::vector< Dali::TouchPoint > *arg1 = 0 ; - std::vector< Dali::TouchPoint > *result = 0 ; - - arg1 = (std::vector< Dali::TouchPoint > *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0); - return 0; - } - { - try { - result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) { - void * jresult ; - int arg1 ; - std::vector< Dali::TouchPoint > *result = 0 ; - - arg1 = (int)jarg1; - { - try { - try { - result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) { - void * jresult ; - std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; - int arg2 ; - SwigValueWrapper< Dali::TouchPoint > result; - - arg1 = (std::vector< Dali::TouchPoint > *)jarg1; - arg2 = (int)jarg2; - { - try { - try { - result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) { - void * jresult ; - std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; - int arg2 ; - Dali::TouchPoint *result = 0 ; - - arg1 = (std::vector< Dali::TouchPoint > *)jarg1; - arg2 = (int)jarg2; - { - try { - try { - result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) { - std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; - int arg2 ; - Dali::TouchPoint *arg3 = 0 ; - - arg1 = (std::vector< Dali::TouchPoint > *)jarg1; - arg2 = (int)jarg2; - arg3 = (Dali::TouchPoint *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0); - return ; - } - { - try { - try { - std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) { - std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; - std::vector< Dali::TouchPoint > *arg2 = 0 ; - - arg1 = (std::vector< Dali::TouchPoint > *)jarg1; - arg2 = (std::vector< Dali::TouchPoint > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0); - return ; - } - { - try { - std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) { - void * jresult ; - std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; - int arg2 ; - int arg3 ; - std::vector< Dali::TouchPoint > *result = 0 ; - - arg1 = (std::vector< Dali::TouchPoint > *)jarg1; - arg2 = (int)jarg2; - arg3 = (int)jarg3; - { - try { - try { - result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - catch(std::invalid_argument &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) { - std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; - int arg2 ; - Dali::TouchPoint *arg3 = 0 ; - - arg1 = (std::vector< Dali::TouchPoint > *)jarg1; - arg2 = (int)jarg2; - arg3 = (Dali::TouchPoint *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0); - return ; - } - { - try { - try { - std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) { - std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; - int arg2 ; - std::vector< Dali::TouchPoint > *arg3 = 0 ; - - arg1 = (std::vector< Dali::TouchPoint > *)jarg1; - arg2 = (int)jarg2; - arg3 = (std::vector< Dali::TouchPoint > *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0); - return ; - } - { - try { - try { - std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) { - std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; - int arg2 ; - - arg1 = (std::vector< Dali::TouchPoint > *)jarg1; - arg2 = (int)jarg2; - { - try { - try { - std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) { - std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; - int arg2 ; - int arg3 ; - - arg1 = (std::vector< Dali::TouchPoint > *)jarg1; - arg2 = (int)jarg2; - arg3 = (int)jarg3; - { - try { - try { - std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - catch(std::invalid_argument &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) { - void * jresult ; - Dali::TouchPoint *arg1 = 0 ; - int arg2 ; - std::vector< Dali::TouchPoint > *result = 0 ; - - arg1 = (Dali::TouchPoint *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0); - return 0; - } - arg2 = (int)jarg2; - { - try { - try { - result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) { - std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; - - arg1 = (std::vector< Dali::TouchPoint > *)jarg1; - { - try { - std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) { - std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; - int arg2 ; - int arg3 ; - - arg1 = (std::vector< Dali::TouchPoint > *)jarg1; - arg2 = (int)jarg2; - arg3 = (int)jarg3; - { - try { - try { - std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - catch(std::invalid_argument &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) { - std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; - int arg2 ; - std::vector< Dali::TouchPoint > *arg3 = 0 ; - - arg1 = (std::vector< Dali::TouchPoint > *)jarg1; - arg2 = (int)jarg2; - arg3 = (std::vector< Dali::TouchPoint > *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0); - return ; - } - { - try { - try { - std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) { - std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ; - - arg1 = (std::vector< Dali::TouchPoint > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() { - void * jresult ; - Dali::Rect< int > *result = 0 ; - - { - try { - result = (Dali::Rect< int > *)new Dali::Rect< int >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) { - void * jresult ; - int arg1 ; - int arg2 ; - int arg3 ; - int arg4 ; - Dali::Rect< int > *result = 0 ; - - arg1 = (int)jarg1; - arg2 = (int)jarg2; - arg3 = (int)jarg3; - arg4 = (int)jarg4; - { - try { - result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) { - void * jresult ; - Dali::Rect< int > *arg1 = 0 ; - Dali::Rect< int > *result = 0 ; - - arg1 = (Dali::Rect< int > *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - Dali::Rect< int > *arg2 = 0 ; - Dali::Rect< int > *result = 0 ; - - arg1 = (Dali::Rect< int > *)jarg1; - arg2 = (Dali::Rect< int > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) { - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int arg2 ; - int arg3 ; - int arg4 ; - int arg5 ; - - arg1 = (Dali::Rect< int > *)jarg1; - arg2 = (int)jarg2; - arg3 = (int)jarg3; - arg4 = (int)jarg4; - arg5 = (int)jarg5; - { - try { - (arg1)->Set(arg2,arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) { - bool jresult ; - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - bool result; - - arg1 = (Dali::Rect< int > *)jarg1; - { - try { - result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) { - int jresult ; - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int result; - - arg1 = (Dali::Rect< int > *)jarg1; - { - try { - result = (int)((Dali::Rect< int > const *)arg1)->Left(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) { - int jresult ; - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int result; - - arg1 = (Dali::Rect< int > *)jarg1; - { - try { - result = (int)((Dali::Rect< int > const *)arg1)->Right(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) { - int jresult ; - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int result; - - arg1 = (Dali::Rect< int > *)jarg1; - { - try { - result = (int)((Dali::Rect< int > const *)arg1)->Top(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) { - int jresult ; - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int result; - - arg1 = (Dali::Rect< int > *)jarg1; - { - try { - result = (int)((Dali::Rect< int > const *)arg1)->Bottom(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) { - int jresult ; - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int result; - - arg1 = (Dali::Rect< int > *)jarg1; - { - try { - result = (int)((Dali::Rect< int > const *)arg1)->Area(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - Dali::Rect< int > *arg2 = 0 ; - bool result; - - arg1 = (Dali::Rect< int > *)jarg1; - arg2 = (Dali::Rect< int > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - Dali::Rect< int > *arg2 = 0 ; - bool result; - - arg1 = (Dali::Rect< int > *)jarg1; - arg2 = (Dali::Rect< int > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) { - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int arg2 ; - - arg1 = (Dali::Rect< int > *)jarg1; - arg2 = (int)jarg2; - if (arg1) (arg1)->x = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) { - int jresult ; - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int result; - - arg1 = (Dali::Rect< int > *)jarg1; - result = (int) ((arg1)->x); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) { - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int arg2 ; - - arg1 = (Dali::Rect< int > *)jarg1; - arg2 = (int)jarg2; - if (arg1) (arg1)->left = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) { - int jresult ; - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int result; - - arg1 = (Dali::Rect< int > *)jarg1; - result = (int) ((arg1)->left); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) { - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int arg2 ; - - arg1 = (Dali::Rect< int > *)jarg1; - arg2 = (int)jarg2; - if (arg1) (arg1)->y = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) { - int jresult ; - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int result; - - arg1 = (Dali::Rect< int > *)jarg1; - result = (int) ((arg1)->y); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) { - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int arg2 ; - - arg1 = (Dali::Rect< int > *)jarg1; - arg2 = (int)jarg2; - if (arg1) (arg1)->right = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) { - int jresult ; - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int result; - - arg1 = (Dali::Rect< int > *)jarg1; - result = (int) ((arg1)->right); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) { - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int arg2 ; - - arg1 = (Dali::Rect< int > *)jarg1; - arg2 = (int)jarg2; - if (arg1) (arg1)->width = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) { - int jresult ; - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int result; - - arg1 = (Dali::Rect< int > *)jarg1; - result = (int) ((arg1)->width); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) { - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int arg2 ; - - arg1 = (Dali::Rect< int > *)jarg1; - arg2 = (int)jarg2; - if (arg1) (arg1)->bottom = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) { - int jresult ; - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int result; - - arg1 = (Dali::Rect< int > *)jarg1; - result = (int) ((arg1)->bottom); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) { - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int arg2 ; - - arg1 = (Dali::Rect< int > *)jarg1; - arg2 = (int)jarg2; - if (arg1) (arg1)->height = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) { - int jresult ; - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int result; - - arg1 = (Dali::Rect< int > *)jarg1; - result = (int) ((arg1)->height); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) { - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int arg2 ; - - arg1 = (Dali::Rect< int > *)jarg1; - arg2 = (int)jarg2; - if (arg1) (arg1)->top = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) { - int jresult ; - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - int result; - - arg1 = (Dali::Rect< int > *)jarg1; - result = (int) ((arg1)->top); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) { - Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ; - - arg1 = (Dali::Rect< int > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() { - void * jresult ; - Dali::Rect< float > *result = 0 ; - - { - try { - result = (Dali::Rect< float > *)new Dali::Rect< float >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) { - void * jresult ; - float arg1 ; - float arg2 ; - float arg3 ; - float arg4 ; - Dali::Rect< float > *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg4; - arg4 = (float)jarg3; - { - try { - result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) { - void * jresult ; - Dali::Rect< float > *arg1 = 0 ; - Dali::Rect< float > *result = 0 ; - - arg1 = (Dali::Rect< float > *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; - Dali::Rect< float > *arg2 = 0 ; - Dali::Rect< float > *result = 0 ; - - arg1 = (Dali::Rect< float > *)jarg1; - arg2 = (Dali::Rect< float > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) { - Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; - float arg2 ; - float arg3 ; - float arg4 ; - float arg5 ; - - arg1 = (Dali::Rect< float > *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg5; - arg5 = (float)jarg4; - { - try { - (arg1)->Set(arg2,arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) { - Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; - float arg2 ; - - arg1 = (Dali::Rect< float > *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->left = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) { - float jresult ; - Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; - float result; - - arg1 = (Dali::Rect< float > *)jarg1; - result = (float) ((arg1)->left); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) { - Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; - float arg2 ; - - arg1 = (Dali::Rect< float > *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->left = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) { - float jresult ; - Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; - float result; - - arg1 = (Dali::Rect< float > *)jarg1; - result = (float) ((arg1)->left); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) { - Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; - float arg2 ; - - arg1 = (Dali::Rect< float > *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->right = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) { - float jresult ; - Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; - float result; - - arg1 = (Dali::Rect< float > *)jarg1; - result = (float) ((arg1)->right); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) { - Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; - float arg2 ; - - arg1 = (Dali::Rect< float > *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->right = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) { - float jresult ; - Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; - float result; - - arg1 = (Dali::Rect< float > *)jarg1; - result = (float) ((arg1)->right); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) { - Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; - float arg2 ; - - arg1 = (Dali::Rect< float > *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->bottom = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) { - float jresult ; - Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; - float result; - - arg1 = (Dali::Rect< float > *)jarg1; - result = (float) ((arg1)->bottom); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) { - Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; - float arg2 ; - - arg1 = (Dali::Rect< float > *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->top = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) { - float jresult ; - Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; - float result; - - arg1 = (Dali::Rect< float > *)jarg1; - result = (float) ((arg1)->top); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) { - Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ; - - arg1 = (Dali::Rect< float > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() { - int jresult ; - int result; - - result = (int)Dali::Vector< int >::BaseType; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() { - void * jresult ; - Dali::Vector< int > *result = 0 ; - - { - try { - result = (Dali::Vector< int > *)new Dali::Vector< int >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) { - Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; - - arg1 = (Dali::Vector< int > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Vector< int > *arg1 = 0 ; - Dali::Vector< int > *result = 0 ; - - arg1 = (Dali::Vector< int > *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; - Dali::Vector< int > *arg2 = 0 ; - Dali::Vector< int > *result = 0 ; - - arg1 = (Dali::Vector< int > *)jarg1; - arg2 = (Dali::Vector< int > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) { - void * jresult ; - Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; - Dali::Vector< int >::Iterator result; - - arg1 = (Dali::Vector< int > *)jarg1; - { - try { - result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) { - void * jresult ; - Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; - Dali::Vector< int >::Iterator result; - - arg1 = (Dali::Vector< int > *)jarg1; - { - try { - result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; - Dali::Vector< int >::SizeType arg2 ; - Dali::Vector< int >::ItemType *result = 0 ; - - arg1 = (Dali::Vector< int > *)jarg1; - arg2 = (Dali::Vector< int >::SizeType)jarg2; - { - try { - result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) { - Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; - Dali::Vector< int >::ItemType *arg2 = 0 ; - Dali::Vector< int >::ItemType temp2 ; - - arg1 = (Dali::Vector< int > *)jarg1; - temp2 = (Dali::Vector< int >::ItemType)jarg2; - arg2 = &temp2; - { - try { - (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) { - Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; - Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ; - Dali::Vector< int >::ItemType *arg3 = 0 ; - Dali::Vector< int >::ItemType temp3 ; - - arg1 = (Dali::Vector< int > *)jarg1; - arg2 = (Dali::Vector< int >::Iterator)jarg2; - temp3 = (Dali::Vector< int >::ItemType)jarg3; - arg3 = &temp3; - { - try { - (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { - Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; - Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ; - Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ; - Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ; - - arg1 = (Dali::Vector< int > *)jarg1; - arg2 = (Dali::Vector< int >::Iterator)jarg2; - arg3 = (Dali::Vector< int >::Iterator)jarg3; - arg4 = (Dali::Vector< int >::Iterator)jarg4; - { - try { - (arg1)->Insert(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) { - Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; - Dali::Vector< int >::SizeType arg2 ; - - arg1 = (Dali::Vector< int > *)jarg1; - arg2 = (Dali::Vector< int >::SizeType)jarg2; - { - try { - (arg1)->Reserve(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) { - Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; - Dali::Vector< int >::SizeType arg2 ; - - arg1 = (Dali::Vector< int > *)jarg1; - arg2 = (Dali::Vector< int >::SizeType)jarg2; - { - try { - (arg1)->Resize(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) { - Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; - Dali::Vector< int >::SizeType arg2 ; - Dali::Vector< int >::ItemType *arg3 = 0 ; - Dali::Vector< int >::ItemType temp3 ; - - arg1 = (Dali::Vector< int > *)jarg1; - arg2 = (Dali::Vector< int >::SizeType)jarg2; - temp3 = (Dali::Vector< int >::ItemType)jarg3; - arg3 = &temp3; - { - try { - (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; - Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ; - Dali::Vector< int >::Iterator result; - - arg1 = (Dali::Vector< int > *)jarg1; - arg2 = (Dali::Vector< int >::Iterator)jarg2; - { - try { - result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) { - void * jresult ; - Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; - Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ; - Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ; - Dali::Vector< int >::Iterator result; - - arg1 = (Dali::Vector< int > *)jarg1; - arg2 = (Dali::Vector< int >::Iterator)jarg2; - arg3 = (Dali::Vector< int >::Iterator)jarg3; - { - try { - result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) { - Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; - Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ; - - arg1 = (Dali::Vector< int > *)jarg1; - arg2 = (Dali::Vector< int >::Iterator)jarg2; - { - try { - (arg1)->Remove(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) { - Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; - Dali::Vector< int > *arg2 = 0 ; - - arg1 = (Dali::Vector< int > *)jarg1; - arg2 = (Dali::Vector< int > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0); - return ; - } - { - try { - (arg1)->Swap(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) { - Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; - - arg1 = (Dali::Vector< int > *)jarg1; - { - try { - (arg1)->Clear(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) { - Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ; - - arg1 = (Dali::Vector< int > *)jarg1; - { - try { - (arg1)->Release(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() { - int jresult ; - int result; - - result = (int)Dali::Vector< float >::BaseType; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() { - void * jresult ; - Dali::Vector< float > *result = 0 ; - - { - try { - result = (Dali::Vector< float > *)new Dali::Vector< float >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) { - Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; - - arg1 = (Dali::Vector< float > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Vector< float > *arg1 = 0 ; - Dali::Vector< float > *result = 0 ; - - arg1 = (Dali::Vector< float > *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; - Dali::Vector< float > *arg2 = 0 ; - Dali::Vector< float > *result = 0 ; - - arg1 = (Dali::Vector< float > *)jarg1; - arg2 = (Dali::Vector< float > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) { - void * jresult ; - Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; - Dali::Vector< float >::Iterator result; - - arg1 = (Dali::Vector< float > *)jarg1; - { - try { - result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) { - void * jresult ; - Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; - Dali::Vector< float >::Iterator result; - - arg1 = (Dali::Vector< float > *)jarg1; - { - try { - result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; - Dali::Vector< float >::SizeType arg2 ; - Dali::Vector< float >::ItemType *result = 0 ; - - arg1 = (Dali::Vector< float > *)jarg1; - arg2 = (Dali::Vector< float >::SizeType)jarg2; - { - try { - result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) { - Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; - Dali::Vector< float >::ItemType *arg2 = 0 ; - Dali::Vector< float >::ItemType temp2 ; - - arg1 = (Dali::Vector< float > *)jarg1; - temp2 = (Dali::Vector< float >::ItemType)jarg2; - arg2 = &temp2; - { - try { - (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) { - Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; - Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ; - Dali::Vector< float >::ItemType *arg3 = 0 ; - Dali::Vector< float >::ItemType temp3 ; - - arg1 = (Dali::Vector< float > *)jarg1; - arg2 = (Dali::Vector< float >::Iterator)jarg2; - temp3 = (Dali::Vector< float >::ItemType)jarg3; - arg3 = &temp3; - { - try { - (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { - Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; - Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ; - Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ; - Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ; - - arg1 = (Dali::Vector< float > *)jarg1; - arg2 = (Dali::Vector< float >::Iterator)jarg2; - arg3 = (Dali::Vector< float >::Iterator)jarg3; - arg4 = (Dali::Vector< float >::Iterator)jarg4; - { - try { - (arg1)->Insert(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) { - Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; - Dali::Vector< float >::SizeType arg2 ; - - arg1 = (Dali::Vector< float > *)jarg1; - arg2 = (Dali::Vector< float >::SizeType)jarg2; - { - try { - (arg1)->Reserve(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - -//// ========================= end of part 2 ============================= - -//// ========================== start part 3 =============================== - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) { - Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; - Dali::Vector< float >::SizeType arg2 ; - - arg1 = (Dali::Vector< float > *)jarg1; - arg2 = (Dali::Vector< float >::SizeType)jarg2; - { - try { - (arg1)->Resize(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) { - Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; - Dali::Vector< float >::SizeType arg2 ; - Dali::Vector< float >::ItemType *arg3 = 0 ; - Dali::Vector< float >::ItemType temp3 ; - - arg1 = (Dali::Vector< float > *)jarg1; - arg2 = (Dali::Vector< float >::SizeType)jarg2; - temp3 = (Dali::Vector< float >::ItemType)jarg3; - arg3 = &temp3; - { - try { - (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; - Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ; - Dali::Vector< float >::Iterator result; - - arg1 = (Dali::Vector< float > *)jarg1; - arg2 = (Dali::Vector< float >::Iterator)jarg2; - { - try { - result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) { - void * jresult ; - Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; - Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ; - Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ; - Dali::Vector< float >::Iterator result; - - arg1 = (Dali::Vector< float > *)jarg1; - arg2 = (Dali::Vector< float >::Iterator)jarg2; - arg3 = (Dali::Vector< float >::Iterator)jarg3; - { - try { - result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) { - Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; - Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ; - - arg1 = (Dali::Vector< float > *)jarg1; - arg2 = (Dali::Vector< float >::Iterator)jarg2; - { - try { - (arg1)->Remove(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) { - Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; - Dali::Vector< float > *arg2 = 0 ; - - arg1 = (Dali::Vector< float > *)jarg1; - arg2 = (Dali::Vector< float > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0); - return ; - } - { - try { - (arg1)->Swap(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) { - Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; - - arg1 = (Dali::Vector< float > *)jarg1; - { - try { - (arg1)->Clear(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) { - Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ; - - arg1 = (Dali::Vector< float > *)jarg1; - { - try { - (arg1)->Release(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() { - int jresult ; - int result; - - result = (int)Dali::Vector< unsigned char >::BaseType; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() { - void * jresult ; - Dali::Vector< unsigned char > *result = 0 ; - - { - try { - result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) { - Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; - - arg1 = (Dali::Vector< unsigned char > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Vector< unsigned char > *arg1 = 0 ; - Dali::Vector< unsigned char > *result = 0 ; - - arg1 = (Dali::Vector< unsigned char > *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; - Dali::Vector< unsigned char > *arg2 = 0 ; - Dali::Vector< unsigned char > *result = 0 ; - - arg1 = (Dali::Vector< unsigned char > *)jarg1; - arg2 = (Dali::Vector< unsigned char > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) { - void * jresult ; - Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; - Dali::Vector< unsigned char >::Iterator result; - - arg1 = (Dali::Vector< unsigned char > *)jarg1; - { - try { - result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) { - void * jresult ; - Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; - Dali::Vector< unsigned char >::Iterator result; - - arg1 = (Dali::Vector< unsigned char > *)jarg1; - { - try { - result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; - Dali::Vector< unsigned char >::SizeType arg2 ; - Dali::Vector< unsigned char >::ItemType *result = 0 ; - - arg1 = (Dali::Vector< unsigned char > *)jarg1; - arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2; - { - try { - result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) { - Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; - Dali::Vector< unsigned char >::ItemType *arg2 = 0 ; - Dali::Vector< unsigned char >::ItemType temp2 ; - - arg1 = (Dali::Vector< unsigned char > *)jarg1; - temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2; - arg2 = &temp2; - { - try { - (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) { - Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; - Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ; - Dali::Vector< unsigned char >::ItemType *arg3 = 0 ; - Dali::Vector< unsigned char >::ItemType temp3 ; - - arg1 = (Dali::Vector< unsigned char > *)jarg1; - arg2 = jarg2; - temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3; - arg3 = &temp3; - { - try { - (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - - - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) { - Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; - Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ; - Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ; - Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ; - - arg1 = (Dali::Vector< unsigned char > *)jarg1; - arg2 = jarg2; - arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3; - arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4; - { - try { - (arg1)->Insert(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - - - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) { - Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; - Dali::Vector< unsigned char >::SizeType arg2 ; - - arg1 = (Dali::Vector< unsigned char > *)jarg1; - arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2; - { - try { - (arg1)->Reserve(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) { - Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; - Dali::Vector< unsigned char >::SizeType arg2 ; - - arg1 = (Dali::Vector< unsigned char > *)jarg1; - arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2; - { - try { - (arg1)->Resize(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) { - Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; - Dali::Vector< unsigned char >::SizeType arg2 ; - Dali::Vector< unsigned char >::ItemType *arg3 = 0 ; - Dali::Vector< unsigned char >::ItemType temp3 ; - - arg1 = (Dali::Vector< unsigned char > *)jarg1; - arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2; - temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3; - arg3 = &temp3; - { - try { - (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) { - void * jresult ; - Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; - Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ; - Dali::Vector< unsigned char >::Iterator result; - - arg1 = (Dali::Vector< unsigned char > *)jarg1; - arg2 = jarg2; - { - try { - result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) { - void * jresult ; - Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; - Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ; - Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ; - Dali::Vector< unsigned char >::Iterator result; - - arg1 = (Dali::Vector< unsigned char > *)jarg1; - arg2 = jarg2; - arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3; - { - try { - result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) { - Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; - Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ; - - arg1 = (Dali::Vector< unsigned char > *)jarg1; - arg2 = jarg2; - { - try { - (arg1)->Remove(arg2); - } CALL_CATCH_EXCEPTION(); - } - - - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) { - Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; - Dali::Vector< unsigned char > *arg2 = 0 ; - - arg1 = (Dali::Vector< unsigned char > *)jarg1; - arg2 = (Dali::Vector< unsigned char > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0); - return ; - } - { - try { - (arg1)->Swap(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) { - Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; - - arg1 = (Dali::Vector< unsigned char > *)jarg1; - { - try { - (arg1)->Clear(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) { - Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ; - - arg1 = (Dali::Vector< unsigned char > *)jarg1; - { - try { - (arg1)->Release(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() { - int jresult ; - int result; - - result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() { - void * jresult ; - Dali::Vector< Dali::Uint16Pair > *result = 0 ; - - { - try { - result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) { - Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; - - arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ; - Dali::Vector< Dali::Uint16Pair > *result = 0 ; - - arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; - Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ; - Dali::Vector< Dali::Uint16Pair > *result = 0 ; - - arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; - arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) { - void * jresult ; - Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; - Dali::Vector< Dali::Uint16Pair >::Iterator result; - - arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; - { - try { - result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) { - void * jresult ; - Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; - Dali::Vector< Dali::Uint16Pair >::Iterator result; - - arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; - { - try { - result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; - Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ; - Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ; - - arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; - arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2; - { - try { - result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) { - Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; - Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ; - - arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; - arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0); - return ; - } - { - try { - (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { - Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; - Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ; - Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ; - - arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; - arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2; - arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0); - return ; - } - { - try { - (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { - Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; - Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ; - Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ; - Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ; - - arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; - arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2; - arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3; - arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4; - { - try { - (arg1)->Insert(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) { - Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; - Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ; - - arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; - arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2; - { - try { - (arg1)->Reserve(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) { - Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; - Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ; - - arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; - arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2; - { - try { - (arg1)->Resize(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) { - Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; - Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ; - Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ; - - arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; - arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2; - arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0); - return ; - } - { - try { - (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; - Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ; - Dali::Vector< Dali::Uint16Pair >::Iterator result; - - arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; - arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2; - { - try { - result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) { - void * jresult ; - Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; - Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ; - Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ; - Dali::Vector< Dali::Uint16Pair >::Iterator result; - - arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; - arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2; - arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3; - { - try { - result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) { - Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; - Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ; - - arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; - arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2; - { - try { - (arg1)->Remove(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) { - Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; - Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ; - - arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; - arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0); - return ; - } - { - try { - (arg1)->Swap(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) { - Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; - - arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; - { - try { - (arg1)->Clear(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) { - Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ; - - arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1; - { - try { - (arg1)->Release(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() { - void * jresult ; - Dali::Signal< void () > *result = 0 ; - - { - try { - result = (Dali::Signal< void () > *)new Dali::Signal< void () >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) { - Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; - - arg1 = (Dali::Signal< void () > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void () > *)jarg1; - { - try { - result = (bool)((Dali::Signal< void () > const *)arg1)->Empty(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void () > *)jarg1; - { - try { - result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) { - Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; - void (*arg2)() = (void (*)()) 0 ; - - arg1 = (Dali::Signal< void () > *)jarg1; - arg2 = (void (*)())jarg2; - { - try { - (arg1)->Connect(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; - void (*arg2)() = (void (*)()) 0 ; - - arg1 = (Dali::Signal< void () > *)jarg1; - arg2 = (void (*)())jarg2; - { - try { - (arg1)->Disconnect(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) { - Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; - Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ; - Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ; - - arg1 = (Dali::Signal< void () > *)jarg1; - arg2 = (Dali::ConnectionTrackerInterface *)jarg2; - arg3 = (Dali::FunctorDelegate *)jarg3; - { - try { - (arg1)->Connect(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) { - Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; - - arg1 = (Dali::Signal< void () > *)jarg1; - { - try { - (arg1)->Emit(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (float) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (float) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ; - void (*arg2)(float) = (void (*)(float)) 0 ; - - arg1 = (Dali::Signal< void (float) > *)jarg1; - arg2 = (void (*)(float))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ; - void (*arg2)(float) = (void (*)(float)) 0 ; - - arg1 = (Dali::Signal< void (float) > *)jarg1; - arg2 = (void (*)(float))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) { - Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ; - float arg2 ; - - arg1 = (Dali::Signal< void (float) > *)jarg1; - arg2 = (float)jarg2; - { - try { - Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() { - void * jresult ; - Dali::Signal< void (float) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) { - Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ; - - arg1 = (Dali::Signal< void (float) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ; - void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ; - - arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1; - arg2 = (void (*)(Dali::BaseHandle))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ; - void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ; - - arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1; - arg2 = (void (*)(Dali::BaseHandle))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ; - Dali::BaseHandle arg2 ; - Dali::BaseHandle *argp2 ; - - arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1; - argp2 = (Dali::BaseHandle *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0); - return ; - } - arg2 = *argp2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() { - void * jresult ; - Dali::Signal< void (Dali::BaseHandle) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) { - Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ; - void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ; - - arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1; - arg2 = (void (*)(Dali::RefObject const *))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ; - void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ; - - arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1; - arg2 = (void (*)(Dali::RefObject const *))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ; - Dali::RefObject *arg2 = (Dali::RefObject *) 0 ; - - arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1; - arg2 = (Dali::RefObject *)jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() { - void * jresult ; - Dali::Signal< void (Dali::RefObject const *) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) { - Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ; - void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1; - arg2 = (void (*)(Dali::PropertyNotification &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ; - void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1; - arg2 = (void (*)(Dali::PropertyNotification &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ; - Dali::PropertyNotification *arg2 = 0 ; - - arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1; - arg2 = (Dali::PropertyNotification *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0); - return ; - } - { - try { - Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() { - void * jresult ; - Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) { - Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() { - void * jresult ; - Dali::Signal< void (Dali::RenderTask &) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) { - Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ; - void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1; - arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ; - void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1; - arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) { - Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ; - Dali::Actor arg2 ; - Dali::LongPressGesture *arg3 = 0 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::LongPressGesture *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0); - return ; - } - { - try { - Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() { - void * jresult ; - Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) { - Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ; - void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1; - arg2 = (void (*)(Dali::KeyEvent const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ; - void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1; - arg2 = (void (*)(Dali::KeyEvent const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ; - Dali::KeyEvent *arg2 = 0 ; - - arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1; - arg2 = (Dali::KeyEvent *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0); - return ; - } - { - try { - Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() { - void * jresult ; - Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) { - Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ; - void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1; - arg2 = (void (*)(Dali::WheelEvent const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ; - void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1; - arg2 = (void (*)(Dali::WheelEvent const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ; - Dali::WheelEvent *arg2 = 0 ; - - arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1; - arg2 = (Dali::WheelEvent *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0); - return ; - } - { - try { - Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() { - void * jresult ; - Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) { - Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() { - void * jresult ; - std::pair< Dali::Radian,Dali::Radian > *result = 0 ; - - { - try { - result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Radian arg1 ; - Dali::Radian arg2 ; - Dali::Radian *argp1 ; - Dali::Radian *argp2 ; - std::pair< Dali::Radian,Dali::Radian > *result = 0 ; - - argp1 = (Dali::Radian *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg1 = *argp1; - argp2 = (Dali::Radian *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) { - void * jresult ; - std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ; - std::pair< Dali::Radian,Dali::Radian > *result = 0 ; - - arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0); - return 0; - } - { - try { - result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) { - std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ; - Dali::Radian *arg2 = (Dali::Radian *) 0 ; - - arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1; - arg2 = (Dali::Radian *)jarg2; - if (arg1) (arg1)->first = *arg2; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) { - void * jresult ; - std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ; - Dali::Radian *result = 0 ; - - arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1; - result = (Dali::Radian *)& ((arg1)->first); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) { - std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ; - Dali::Radian *arg2 = (Dali::Radian *) 0 ; - - arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1; - arg2 = (Dali::Radian *)jarg2; - if (arg1) (arg1)->second = *arg2; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) { - void * jresult ; - std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ; - Dali::Radian *result = 0 ; - - arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1; - result = (Dali::Radian *)& ((arg1)->second); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) { - std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ; - - arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ; - void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1; - arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ; - void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1; - arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) { - Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ; - Dali::Actor arg2 ; - Dali::PanGesture *arg3 = 0 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::PanGesture *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0); - return ; - } - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() { - void * jresult ; - Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) { - Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ; - void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1; - arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ; - void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1; - arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) { - Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ; - Dali::Actor arg2 ; - Dali::PinchGesture *arg3 = 0 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::PinchGesture *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0); - return ; - } - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() { - void * jresult ; - Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) { - Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ; - void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1; - arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ; - void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1; - arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) { - Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ; - Dali::Actor arg2 ; - Dali::TapGesture *arg3 = 0 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::TapGesture *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0); - return ; - } - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() { - void * jresult ; - Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) { - Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ; - std::size_t result = 0; - - arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *)arg1); - }CALL_CATCH_EXCEPTION(0); - } - jresult = (unsigned long)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ; - void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1; - arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ; - void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1; - arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) { - Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ; - Dali::Actor arg2 ; - //bool arg3 ; - Dali::LayoutDirection::Type arg4 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - //arg3 = jarg3 ? true : false; - arg4 = (Dali::LayoutDirection::Type)jarg4; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() { - void * jresult ; - Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) { - Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() { - void * jresult ; - Dali::Timer *result = 0 ; - - { - try { - result = (Dali::Timer *)new Dali::Timer(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) { - void * jresult ; - unsigned int arg1 ; - Dali::Timer result; - - arg1 = (unsigned int)jarg1; - { - try { - result = Dali::Timer::New(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Timer((const Dali::Timer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Timer *arg1 = 0 ; - Dali::Timer *result = 0 ; - - arg1 = (Dali::Timer *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Timer *arg1 = (Dali::Timer *) 0 ; - Dali::Timer *arg2 = 0 ; - Dali::Timer *result = 0 ; - - arg1 = (Dali::Timer *)jarg1; - arg2 = (Dali::Timer *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) { - Dali::Timer *arg1 = (Dali::Timer *) 0 ; - - arg1 = (Dali::Timer *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Timer 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::Timer::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Timer((const Dali::Timer &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) { - Dali::Timer *arg1 = (Dali::Timer *) 0 ; - - arg1 = (Dali::Timer *)jarg1; - { - try { - (arg1)->Start(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) { - Dali::Timer *arg1 = (Dali::Timer *) 0 ; - - arg1 = (Dali::Timer *)jarg1; - { - try { - (arg1)->Stop(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) { - Dali::Timer *arg1 = (Dali::Timer *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Timer *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - (arg1)->SetInterval(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) { - unsigned int jresult ; - Dali::Timer *arg1 = (Dali::Timer *) 0 ; - unsigned int result; - - arg1 = (Dali::Timer *)jarg1; - { - try { - result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) { - bool jresult ; - Dali::Timer *arg1 = (Dali::Timer *) 0 ; - bool result; - - arg1 = (Dali::Timer *)jarg1; - { - try { - result = (bool)((Dali::Timer const *)arg1)->IsRunning(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) { - void * jresult ; - Dali::Timer *arg1 = (Dali::Timer *) 0 ; - Dali::Timer::TimerSignalType *result = 0 ; - - arg1 = (Dali::Timer *)jarg1; - { - try { - result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ; - bool result; - - arg1 = (Dali::Signal< bool () > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< bool () > *)jarg1; - { - try { - result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) { - Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ; - bool (*arg2)() = (bool (*)()) 0 ; - - arg1 = (Dali::Signal< bool () > *)jarg1; - arg2 = (bool (*)())jarg2; - { - try { - Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ; - bool (*arg2)() = (bool (*)()) 0 ; - - arg1 = (Dali::Signal< bool () > *)jarg1; - arg2 = (bool (*)())jarg2; - { - try { - Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) { - bool jresult ; - Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ; - bool result; - - arg1 = (Dali::Signal< bool () > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() { - void * jresult ; - Dali::Signal< bool () > *result = 0 ; - - { - try { - result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) { - Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ; - - arg1 = (Dali::Signal< bool () > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Visual::Property::TYPE; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Visual::Property::SHADER; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::BorderVisual::Property::COLOR; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::BorderVisual::Property::SIZE; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::GradientVisual::Property::CENTER; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::GradientVisual::Property::UNITS; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::ImageVisual::Property::URL; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() { - int jresult ; - int result; - { - try - { - result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() { - int jresult ; - int result; - { - try - { - result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() { - int jresult ; - int result; - { - try - { - result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() { - return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() { - int jresult ; - int result; - { - try - { - result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() { - int jresult ; - int result; - { - try - { - result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() { - int jresult ; - int result; - { - try - { - result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() { - int jresult ; - int result; - { - try - { - result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() { - int jresult ; - int result; - { - try - { - result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() { - int jresult ; - int result; - { - try - { - result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() { - int jresult ; - int result; - { - try - { - result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PLACEHOLDER_IMAGE_get() { - int jresult; - int result; - result = (int)Dali::Toolkit::ImageView::Property::PLACEHOLDER_IMAGE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_TRANSITION_EFFECT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ImageView::Property::ENABLE_TRANSITION_EFFECT; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -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; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::ImageVisual::Property::BORDER; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE; - } CALL_CATCH_EXCEPTION(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; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS; - } CALL_CATCH_EXCEPTION(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; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::TextVisual::Property::TEXT; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() { - void * jresult ; - Dali::Toolkit::Builder *result = 0 ; - - { - try { - result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() { - void * jresult ; - Dali::Toolkit::Builder result; - - { - try { - result = Dali::Toolkit::Builder::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) { - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) { - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - std::string *arg2 = 0 ; - Dali::Toolkit::Builder::UIFormat arg3 ; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3; - { - try { - (arg1)->LoadFromString((std::string const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - - - //argout typemap for const std::string& - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) { - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - (arg1)->LoadFromString((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - - - //argout typemap for const std::string& - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) { - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - Dali::Property::Map *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - arg2 = (Dali::Property::Map *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); - return ; - } - { - try { - (arg1)->AddConstants((Dali::Property::Map const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) { - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - std::string *arg2 = 0 ; - Dali::Property::Value *arg3 = 0 ; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Property::Value *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); - return ; - } - { - try { - (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - - - //argout typemap for const std::string& - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) { - void * jresult ; - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - Dali::Property::Map *result = 0 ; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - { - try { - result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) { - void * jresult ; - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - std::string *arg2 = 0 ; - Dali::Property::Value *result = 0 ; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) { - void * jresult ; - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - std::string *arg2 = 0 ; - Dali::Animation result; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - result = (arg1)->CreateAnimation((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Animation((const Dali::Animation &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) { - void * jresult ; - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - std::string *arg2 = 0 ; - Dali::Property::Map *arg3 = 0 ; - Dali::Animation result; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Property::Map *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); - return 0; - } - { - try { - result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Animation((const Dali::Animation &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) { - void * jresult ; - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - std::string *arg2 = 0 ; - Dali::Actor arg3 ; - Dali::Actor *argp3 ; - Dali::Animation result; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - argp3 = (Dali::Actor *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg3 = *argp3; - { - try { - result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Animation((const Dali::Animation &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) { - void * jresult ; - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - std::string *arg2 = 0 ; - Dali::Property::Map *arg3 = 0 ; - Dali::Actor arg4 ; - Dali::Actor *argp4 ; - Dali::Animation result; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Property::Map *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); - return 0; - } - argp4 = (Dali::Actor *)jarg4; - if (!argp4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg4 = *argp4; - { - try { - result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Animation((const Dali::Animation &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) { - void * jresult ; - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - std::string *arg2 = 0 ; - Dali::BaseHandle result; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - result = (arg1)->Create((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) { - void * jresult ; - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - std::string *arg2 = 0 ; - Dali::Property::Map *arg3 = 0 ; - Dali::BaseHandle result; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Property::Map *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); - return 0; - } - { - try { - result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) { - void * jresult ; - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - std::string *arg2 = 0 ; - Dali::BaseHandle result; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - result = (arg1)->CreateFromJson((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) { - bool jresult ; - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - std::string *arg2 = 0 ; - Dali::Handle *arg3 = 0 ; - bool result; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Handle *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); - return 0; - } - { - try { - result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) { - bool jresult ; - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - Dali::Handle *arg2 = 0 ; - std::string *arg3 = 0 ; - bool result; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - arg2 = (Dali::Handle *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0); - return 0; - } - if (!jarg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg3_str(jarg3); - arg3 = &arg3_str; - { - try { - result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) { - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->AddActors(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) { - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - std::string *arg2 = 0 ; - Dali::Actor arg3 ; - Dali::Actor *argp3 ; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - argp3 = (Dali::Actor *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg3 = *argp3; - { - try { - (arg1)->AddActors((std::string const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - - - //argout typemap for const std::string& - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) { - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - (arg1)->CreateRenderTask((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - - - //argout typemap for const std::string& - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) { - void * jresult ; - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - std::string *arg2 = 0 ; - Dali::Path result; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - result = (arg1)->GetPath((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Path((const Dali::Path &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) { - void * jresult ; - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - std::string *arg2 = 0 ; - Dali::PathConstrainer result; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - result = (arg1)->GetPathConstrainer((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) { - void * jresult ; - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - std::string *arg2 = 0 ; - Dali::LinearConstrainer result; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - result = (arg1)->GetLinearConstrainer((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ; - Dali::Toolkit::Builder::BuilderSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::Builder *)jarg1; - { - try { - result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -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(); - } CALL_CATCH_EXCEPTION(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; - } CALL_CATCH_EXCEPTION(); - } - -} - - -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); - } CALL_CATCH_EXCEPTION(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); - } CALL_CATCH_EXCEPTION(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); - } CALL_CATCH_EXCEPTION(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); - } CALL_CATCH_EXCEPTION(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); - } CALL_CATCH_EXCEPTION(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(); - } CALL_CATCH_EXCEPTION(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); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Property::Map((const Dali::Property::Map &)result); - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Tooltip::Property::CONTENT; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Tooltip::Property::TAIL; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Tooltip::Property::POSITION; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() { - void * jresult ; - Dali::Toolkit::Control result; - - { - try { - result = Dali::Toolkit::Internal::Control::New(Dali::Toolkit::Internal::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - (arg1)->SetStyleName((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - - - //argout typemap for const std::string& - -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) { - char * jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - std::string *result = 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Vector4 *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) { - void * jresult ; - Dali::Handle *arg1 = (Dali::Handle *) 0 ; - Dali::Vector4 result; - - arg1 = (Dali::Handle *)jarg1; - { - try { - Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap(); - if (resultMap) - { - Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE ); - if(type && type->Get() == Visual::COLOR ) - { - Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR ); - if (value) - { - result = value->Get(); - } - } - } - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Property::Map *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::Property::Map *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); - return ; - } - { - try { - (arg1)->SetBackground((Dali::Property::Map const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - (arg1)->ClearBackground(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::GestureType::Value arg2 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::GestureType::Value)jarg2; - { - try { - (arg1)->EnableGestureDetection(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::GestureType::Value arg2 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::GestureType::Value)jarg2; - { - try { - (arg1)->DisableGestureDetection(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) { - void * jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::PinchGestureDetector result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) { - void * jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::PanGestureDetector result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) { - void * jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::TapGestureDetector result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) { - void * jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::LongPressGestureDetector result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, bool jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - bool arg2 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - (arg1)->SetKeyboardNavigationSupport(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) { - bool jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - result = (bool)(arg1)->IsKeyboardNavigationSupported(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - (arg1)->SetKeyInputFocus(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) { - bool jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - result = (bool)(arg1)->HasKeyInputFocus(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - (arg1)->ClearKeyInputFocus(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, bool jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - bool arg2 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - (arg1)->SetAsKeyboardFocusGroup(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) { - bool jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - result = (bool)(arg1)->IsKeyboardFocusGroup(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Toolkit::Control::KeyEventSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - int arg2 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (int)jarg2; - darg = dynamic_cast(arg1); - if(!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - if(darg) { - (darg)->OnSceneConnection(arg2); - } - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - int arg2 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (int)jarg2; - darg = dynamic_cast(arg1); - if(!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - if(darg) { - (darg)->OnSceneConnectionSwigPublic(arg2); - } - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - darg = dynamic_cast(arg1); - if(!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - if(darg) { - (darg)->OnSceneDisconnection(); - } - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - darg = dynamic_cast(arg1); - if(!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - if(darg) { - (darg)->OnSceneDisconnectionSwigPublic(); - } - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Actor *arg2 = 0 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::Actor *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); - return ; - } - darg = dynamic_cast(arg1); - if(!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - if(darg) { - (darg)->OnChildAdd(*arg2); - } - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Actor *arg2 = 0 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::Actor *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); - return ; - } - darg = dynamic_cast(arg1); - if(!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - if(darg) { - (darg)->OnChildAddSwigPublic(*arg2); - } - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Actor *arg2 = 0 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::Actor *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); - return ; - } - darg = dynamic_cast(arg1); - if(!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - if(darg) { - (darg)->OnChildRemove(*arg2); - } - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Actor *arg2 = 0 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::Actor *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); - return ; - } - darg = dynamic_cast(arg1); - if(!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - if(darg) { - (darg)->OnChildRemoveSwigPublic(*arg2); - } - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Property::Index arg2 ; - Dali::Property::Value arg3 ; - Dali::Property::Value *argp3 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - argp3 = (Dali::Property::Value *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0); - return ; - } - arg3 = *argp3; - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - (darg)->OnPropertySet(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Vector3 *arg2 = 0 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - (darg)->OnSizeSet((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Vector3 *arg2 = 0 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Animation *arg2 = 0 ; - Dali::Vector3 *arg3 = 0 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::Animation *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0); - return ; - } - arg3 = (Dali::Vector3 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Animation *arg2 = 0 ; - Dali::Vector3 *arg3 = 0 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::Animation *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0); - return ; - } - arg3 = (Dali::Vector3 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::KeyEvent *arg2 = 0 ; - SwigDirector_ViewImpl *darg = 0; - bool result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::KeyEvent *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0); - return 0; - } - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return 0; - } - { - try { - result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::KeyEvent *arg2 = 0 ; - SwigDirector_ViewImpl *darg = 0; - bool result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::KeyEvent *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0); - return 0; - } - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return 0; - } - { - try { - result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Vector2 *arg2 = 0 ; - Dali::RelayoutContainer *arg3 = 0 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - arg3 = (Dali::RelayoutContainer *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0); - return ; - } - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Vector2 *arg2 = 0 ; - Dali::RelayoutContainer *arg3 = 0 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - arg3 = (Dali::RelayoutContainer *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0); - return ; - } - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::ResizePolicy::Type arg2 ; - Dali::Dimension::Type arg3 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::ResizePolicy::Type)jarg2; - arg3 = (Dali::Dimension::Type)jarg3; - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - (darg)->OnSetResizePolicy(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::ResizePolicy::Type arg2 ; - Dali::Dimension::Type arg3 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::ResizePolicy::Type)jarg2; - arg3 = (Dali::Dimension::Type)jarg3; - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - (darg)->OnSetResizePolicySwigPublic(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) { - void * jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - SwigDirector_ViewImpl *darg = 0; - Dali::Vector3 result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return 0; - } - { - try { - result = (darg)->GetNaturalSize(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) { - void * jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - SwigDirector_ViewImpl *darg = 0; - Dali::Vector3 result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return 0; - } - { - try { - result = (darg)->GetNaturalSizeSwigPublic(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) { - float jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Actor *arg2 = 0 ; - Dali::Dimension::Type arg3 ; - SwigDirector_ViewImpl *darg = 0; - float result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::Actor *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); - return 0; - } - arg3 = (Dali::Dimension::Type)jarg3; - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return 0; - } - { - try { - result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) { - float jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Actor *arg2 = 0 ; - Dali::Dimension::Type arg3 ; - SwigDirector_ViewImpl *darg = 0; - float result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::Actor *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); - return 0; - } - arg3 = (Dali::Dimension::Type)jarg3; - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return 0; - } - { - try { - result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) { - float jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - float arg2 ; - SwigDirector_ViewImpl *darg = 0; - float result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (float)jarg2; - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return 0; - } - { - try { - result = (float)(darg)->GetHeightForWidth(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) { - float jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - float arg2 ; - SwigDirector_ViewImpl *darg = 0; - float result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (float)jarg2; - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return 0; - } - { - try { - result = (float)(darg)->GetHeightForWidthSwigPublic(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) { - float jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - float arg2 ; - SwigDirector_ViewImpl *darg = 0; - float result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (float)jarg2; - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return 0; - } - { - try { - result = (float)(darg)->GetWidthForHeight(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) { - float jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - float arg2 ; - SwigDirector_ViewImpl *darg = 0; - float result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (float)jarg2; - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return 0; - } - { - try { - result = (float)(darg)->GetWidthForHeightSwigPublic(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) { - bool jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Dimension::Type arg2 ; - SwigDirector_ViewImpl *darg = 0; - bool result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::Dimension::Type)jarg2; - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return 0; - } - { - try { - result = (bool)(darg)->RelayoutDependentOnChildren(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) { - bool jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Dimension::Type arg2 ; - SwigDirector_ViewImpl *darg = 0; - bool result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::Dimension::Type)jarg2; - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return 0; - } - { - try { - result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) { - bool jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - SwigDirector_ViewImpl *darg = 0; - bool result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return 0; - } - { - try { - result = (bool)(darg)->RelayoutDependentOnChildren(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) { - bool jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - SwigDirector_ViewImpl *darg = 0; - bool result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return 0; - } - { - try { - result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Dimension::Type arg2 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::Dimension::Type)jarg2; - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - (darg)->OnCalculateRelayoutSize(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Dimension::Type arg2 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::Dimension::Type)jarg2; - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - (darg)->OnCalculateRelayoutSizeSwigPublic(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - float arg2 ; - Dali::Dimension::Type arg3 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (float)jarg2; - arg3 = (Dali::Dimension::Type)jarg3; - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - (darg)->OnLayoutNegotiated(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - float arg2 ; - Dali::Dimension::Type arg3 ; - SwigDirector_ViewImpl *darg = 0; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (float)jarg2; - arg3 = (Dali::Dimension::Type)jarg3; - darg = dynamic_cast(arg1); - if (!darg) { - SWIG_CSharpException(SWIG_TypeError, "dynamic_cast error. darg is null"); - return; - } - { - try { - (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - (arg1)->OnInitialize(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - (arg1)->Dali::Toolkit::Internal::Control::OnInitialize(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Toolkit::StyleManager arg2 ; - Dali::StyleChange::Type arg3 ; - Dali::Toolkit::StyleManager *argp2 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - argp2 = (Dali::Toolkit::StyleManager *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::StyleChange::Type)jarg3; - { - try { - (arg1)->OnStyleChange(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Toolkit::StyleManager arg2 ; - Dali::StyleChange::Type arg3 ; - Dali::Toolkit::StyleManager *argp2 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - argp2 = (Dali::Toolkit::StyleManager *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::StyleChange::Type)jarg3; - { - try { - (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) { - bool jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - result = (bool)(arg1)->OnAccessibilityActivated(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) { - bool jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::PanGesture arg2 ; - Dali::PanGesture *argp2 ; - bool result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - argp2 = (Dali::PanGesture *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (bool)(arg1)->OnAccessibilityPan(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::PanGesture arg2 ; - Dali::PanGesture *argp2 ; - bool result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - argp2 = (Dali::PanGesture *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, bool jarg2) { - bool jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - bool arg2 ; - bool result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - result = (bool)(arg1)->OnAccessibilityValueChange(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, bool jarg2) { - bool jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - bool arg2 ; - bool result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) { - bool jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - result = (bool)(arg1)->OnAccessibilityZoom(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) { - bool jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - (arg1)->OnKeyInputFocusGained(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - (arg1)->OnKeyInputFocusLost(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, bool jarg4) { - void * jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Actor arg2 ; - Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ; - bool arg4 ; - Dali::Actor *argp2 ; - Dali::Actor result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg2 = *argp2; - arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3; - arg4 = jarg4 ? true : false; - { - try { - result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, bool jarg4) { - void * jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Actor arg2 ; - Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ; - bool arg4 ; - Dali::Actor *argp2 ; - Dali::Actor result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg2 = *argp2; - arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3; - arg4 = jarg4 ? true : false; - { - try { - result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->OnKeyboardFocusChangeCommitted(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) { - bool jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - result = (bool)(arg1)->OnKeyboardEnter(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) { - bool jresult ; - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - { - try { - result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::PinchGesture *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::PinchGesture *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0); - return ; - } - { - try { - (arg1)->OnPinch((Dali::PinchGesture const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::PinchGesture *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::PinchGesture *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0); - return ; - } - { - try { - (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::PanGesture *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::PanGesture *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0); - return ; - } - { - try { - (arg1)->OnPan((Dali::PanGesture const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::PanGesture *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::PanGesture *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0); - return ; - } - { - try { - (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::TapGesture *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::TapGesture *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0); - return ; - } - { - try { - (arg1)->OnTap((Dali::TapGesture const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::TapGesture *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::TapGesture *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0); - return ; - } - { - try { - (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::LongPressGesture *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::LongPressGesture *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0); - return ; - } - { - try { - (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::LongPressGesture *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::LongPressGesture *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0); - return ; - } - { - try { - (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; - Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::SlotObserver *)jarg2; - arg3 = (Dali::CallbackBase *)jarg3; - { - try { - (arg1)->SignalConnected(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; - Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::SlotObserver *)jarg2; - arg3 = (Dali::CallbackBase *)jarg3; - { - try { - (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; - Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::SlotObserver *)jarg2; - arg3 = (Dali::CallbackBase *)jarg3; - { - try { - (arg1)->SignalDisconnected(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) { - Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ; - Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; - Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - arg2 = (Dali::SlotObserver *)jarg2; - arg3 = (Dali::CallbackBase *)jarg3; - { - try { - (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_director_connect(void *objarg, SwigDirector_ViewImpl::SWIG_Callback0_t callback0, SwigDirector_ViewImpl::SWIG_Callback1_t callback1, SwigDirector_ViewImpl::SWIG_Callback2_t callback2, SwigDirector_ViewImpl::SWIG_Callback3_t callback3, SwigDirector_ViewImpl::SWIG_Callback4_t callback4, SwigDirector_ViewImpl::SWIG_Callback5_t callback5, SwigDirector_ViewImpl::SWIG_Callback6_t callback6, SwigDirector_ViewImpl::SWIG_Callback9_t callback9, SwigDirector_ViewImpl::SWIG_Callback11_t callback11, SwigDirector_ViewImpl::SWIG_Callback12_t callback12, SwigDirector_ViewImpl::SWIG_Callback13_t callback13, SwigDirector_ViewImpl::SWIG_Callback14_t callback14, SwigDirector_ViewImpl::SWIG_Callback15_t callback15, SwigDirector_ViewImpl::SWIG_Callback16_t callback16, SwigDirector_ViewImpl::SWIG_Callback17_t callback17, SwigDirector_ViewImpl::SWIG_Callback18_t callback18, SwigDirector_ViewImpl::SWIG_Callback19_t callback19, SwigDirector_ViewImpl::SWIG_Callback20_t callback20, SwigDirector_ViewImpl::SWIG_Callback21_t callback21, SwigDirector_ViewImpl::SWIG_Callback24_t callback24, SwigDirector_ViewImpl::SWIG_Callback25_t callback25, SwigDirector_ViewImpl::SWIG_Callback26_t callback26, SwigDirector_ViewImpl::SWIG_Callback28_t callback28, SwigDirector_ViewImpl::SWIG_Callback29_t callback29, SwigDirector_ViewImpl::SWIG_Callback30_t callback30, SwigDirector_ViewImpl::SWIG_Callback31_t callback31, SwigDirector_ViewImpl::SWIG_Callback32_t callback32, SwigDirector_ViewImpl::SWIG_Callback33_t callback33, SwigDirector_ViewImpl::SWIG_Callback34_t callback34, SwigDirector_ViewImpl::SWIG_Callback35_t callback35, SwigDirector_ViewImpl::SWIG_Callback36_t callback36, SwigDirector_ViewImpl::SWIG_Callback37_t callback37, SwigDirector_ViewImpl::SWIG_Callback38_t callback38, SwigDirector_ViewImpl::SWIG_Callback39_t callback39, SwigDirector_ViewImpl::SWIG_Callback40_t callback40) { - Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg; - SwigDirector_ViewImpl *director = dynamic_cast(obj); - if (director) { - director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback9, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback24, callback25, callback26, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40); - } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) { - void * jresult ; - Dali::Toolkit::Control *arg1 = 0 ; - Dali::Toolkit::Internal::Control *result = 0 ; - - arg1 = (Dali::Toolkit::Control *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Control::Property::STYLE_NAME; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Control::Property::BACKGROUND; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Control::Property::MARGIN; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Control::Property::PADDING; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelControl::Property::SHADOW; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_NAME_get() { - return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_NAME; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_DESCRIPTION_get() { - return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_DESCRIPTION; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_TRANSLATION_DOMAIN_get() { - return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_TRANSLATION_DOMAIN; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_ROLE_get() { - return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_ROLE; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_HIGHLIGHTABLE_get() { - return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_ATTRIBUTES_get() { - return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_ACCESSIBILITY_HIDDEN_get() { - return (int)Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_HIDDEN; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_AUTOMATION_ID_get() { - return (int)Dali::Toolkit::DevelControl::Property::AUTOMATION_ID; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() { - void * jresult ; - Dali::Toolkit::Control::Property *result = 0 ; - - { - try { - result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) { - Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ; - - arg1 = (Dali::Toolkit::Control::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() { - void * jresult ; - Dali::Toolkit::Control::KeyboardFocus *result = 0 ; - - { - try { - result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) { - Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ; - - arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() { - void * jresult ; - Dali::Toolkit::Control result; - - { - try { - result = Dali::Toolkit::Control::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_NewCustom() { - void * jresult; - Dali::Toolkit::Control result; - - { - try { - result = SlimCustomViewImpl::New(Dali::Toolkit::Internal::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() { - void * jresult ; - Dali::Toolkit::Control *result = 0 ; - - { - try { - result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::Control *arg1 = 0 ; - Dali::Toolkit::Control *result = 0 ; - - arg1 = (Dali::Toolkit::Control *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) { - Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; - - arg1 = (Dali::Toolkit::Control *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; - Dali::Toolkit::Control *arg2 = 0 ; - Dali::Toolkit::Control *result = 0 ; - - arg1 = (Dali::Toolkit::Control *)jarg1; - arg2 = (Dali::Toolkit::Control *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::Control 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::Control::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Control(void * jarg1) { - Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) jarg1; - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) { - Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; - - arg1 = (Dali::Toolkit::Control *)jarg1; - { - try { - (arg1)->SetKeyInputFocus(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) { - bool jresult ; - Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::Control *)jarg1; - { - try { - result = (bool)(arg1)->HasKeyInputFocus(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) { - Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; - - arg1 = (Dali::Toolkit::Control *)jarg1; - { - try { - (arg1)->ClearKeyInputFocus(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) { - void * jresult ; - Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; - Dali::PinchGestureDetector result; - - arg1 = (Dali::Toolkit::Control *)jarg1; - { - try { - result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) { - void * jresult ; - Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; - Dali::PanGestureDetector result; - - arg1 = (Dali::Toolkit::Control *)jarg1; - { - try { - result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) { - void * jresult ; - Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; - Dali::TapGestureDetector result; - - arg1 = (Dali::Toolkit::Control *)jarg1; - { - try { - result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) { - void * jresult ; - Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; - Dali::LongPressGestureDetector result; - - arg1 = (Dali::Toolkit::Control *)jarg1; - { - try { - result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) { - Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Control *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - (arg1)->SetStyleName((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - - - //argout typemap for const std::string& - -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) { - char * jresult ; - Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; - std::string *result = 0 ; - - arg1 = (Dali::Toolkit::Control *)jarg1; - { - try { - result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) { - Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; - Dali::Vector4 *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Control *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) { - Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; - - arg1 = (Dali::Toolkit::Control *)jarg1; - { - try { - (arg1)->ClearBackground(); - } CALL_CATCH_EXCEPTION(); - } - -} - -#ifndef GENERATE_CONTROL_SIGNAL -#define GENERATE_CONTROL_SIGNAL(HType, SignalName) GENERATE_SIGNAL(Dali::Toolkit::Control*, HType, Dali_View, SignalName) -#endif - -GENERATE_CONTROL_SIGNAL(bool(*)(Dali::Toolkit::Control, Dali::KeyEvent const&), KeyEventSignal) -// CSharp_Dali_View_KeyEventSignal_Connect -// CSharp_Dali_View_KeyEventSignal_Disconnect - -GENERATE_CONTROL_SIGNAL(void(*)(Dali::Toolkit::Control), KeyInputFocusGainedSignal) -// CSharp_Dali_View_KeyInputFocusGainedSignal_Connect -// CSharp_Dali_View_KeyInputFocusGainedSignal_Disconnect - -GENERATE_CONTROL_SIGNAL(void(*)(Dali::Toolkit::Control), KeyInputFocusLostSignal) -// CSharp_Dali_View_KeyInputFocusLostSignal_Connect -// CSharp_Dali_View_KeyInputFocusLostSignal_Disconnect - -GENERATE_CONTROL_SIGNAL(void(*)(Dali::Toolkit::Control), ResourceReadySignal) -// CSharp_Dali_View_ResourceReadySignal_Connect -// CSharp_Dali_View_ResourceReadySignal_Disconnect - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::Control *arg1 = 0 ; - Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ; - - arg1 = (Dali::Toolkit::Control *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) { - void * jresult ; - Dali::Toolkit::Internal::Control *arg1 = 0 ; - Dali::Toolkit::Control *result = 0 ; - - arg1 = (Dali::Toolkit::Internal::Control *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2) -{ - int jresult; - Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; - arg1 = (Dali::Toolkit::Control *)jarg1; - - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0); - return 0; - } - - Dali::Property::Index arg2 = 0 ; - arg2 = (Dali::Property::Index)jarg2; - - Toolkit::Visual::ResourceStatus result; - { - try { - result = arg1->GetVisualResourceStatus(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2) -{ - void * jresult; - Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ; - arg1 = (Dali::Toolkit::Control *)jarg1; - - Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 ); - - Dali::Toolkit::TransitionData *arg2 = 0 ; - Dali::Animation result; - - arg2 = (Dali::Toolkit::TransitionData *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0); - return 0; - } - { - try { - result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Animation((const Dali::Animation &)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 ) -{ - Dali::Toolkit::Control arg1; - Dali::Toolkit::Control *argp1 = (Dali::Toolkit::Control *)jarg1; - - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0); - } - arg1 = *argp1; - - Dali::Property::Index arg2 = 0 ; - arg2 = (Dali::Property::Index)jarg2; - - Dali::Property::Index arg3 = 0 ; - arg3 = (Dali::Property::Index)jarg3; - - Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4; - - { - try { - DevelControl::DoAction(arg1, arg2, arg3, *arg4); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_View_GetVisualProperty(void* control, int propertyIndex, int visualPropertyIndex) -{ - if (!control) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Given control is null", 0); - return 0; - } - - void* result = 0; - try - { - Dali::Property property = DevelControl::GetVisualProperty(*((Dali::Toolkit::Control*)control), (Dali::Property::Index)propertyIndex, (Dali::Property::Index)visualPropertyIndex); - result = new Dali::Property(property.object, property.propertyIndex, property.componentIndex); - } - CALL_CATCH_EXCEPTION(0); - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) { - bool jresult ; - Dali::Toolkit::Control *arg1 = 0 ; - bool result; - - arg1 = (Dali::Toolkit::Control *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0); - return 0; - } - { - try { - result = (bool)arg1->IsResourceReady(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() { - void * jresult ; - Dali::Toolkit::KeyInputFocusManager *result = 0 ; - - { - try { - result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager(); - } CALL_CATCH_EXCEPTION(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; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() { - void * jresult ; - Dali::Toolkit::KeyInputFocusManager result; - - { - try { - result = Dali::Toolkit::KeyInputFocusManager::Get(); - } CALL_CATCH_EXCEPTION(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); - } CALL_CATCH_EXCEPTION(); - } - -} - - -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(); - } CALL_CATCH_EXCEPTION(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); - } CALL_CATCH_EXCEPTION(); - } - -} - - -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(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() { - void * jresult ; - Dali::Toolkit::Alignment::Padding *result = 0 ; - - { - try { - result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) { - void * jresult ; - float arg1 ; - float arg2 ; - float arg3 ; - float arg4 ; - Dali::Toolkit::Alignment::Padding *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - { - try { - result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) { - Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->left = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) { - float jresult ; - Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ; - float result; - - arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1; - result = (float) ((arg1)->left); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) { - Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->right = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) { - float jresult ; - Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ; - float result; - - arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1; - result = (float) ((arg1)->right); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) { - Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->top = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) { - float jresult ; - Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ; - float result; - - arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1; - result = (float) ((arg1)->top); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) { - Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->bottom = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) { - float jresult ; - Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ; - float result; - - arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1; - result = (float) ((arg1)->bottom); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) { - Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ; - - arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() { - void * jresult ; - Dali::Toolkit::Alignment *result = 0 ; - - { - try { - result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) { - void * jresult ; - Dali::Toolkit::Alignment::Type arg1 ; - Dali::Toolkit::Alignment::Type arg2 ; - Dali::Toolkit::Alignment result; - - arg1 = (Dali::Toolkit::Alignment::Type)jarg1; - arg2 = (Dali::Toolkit::Alignment::Type)jarg2; - { - try { - result = Dali::Toolkit::Alignment::New(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) { - void * jresult ; - Dali::Toolkit::Alignment::Type arg1 ; - Dali::Toolkit::Alignment result; - - arg1 = (Dali::Toolkit::Alignment::Type)jarg1; - { - try { - result = Dali::Toolkit::Alignment::New(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() { - void * jresult ; - Dali::Toolkit::Alignment result; - - { - try { - result = Dali::Toolkit::Alignment::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::Alignment *arg1 = 0 ; - Dali::Toolkit::Alignment *result = 0 ; - - arg1 = (Dali::Toolkit::Alignment *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) { - Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ; - - arg1 = (Dali::Toolkit::Alignment *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::Alignment 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::Alignment::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) { - Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ; - Dali::Toolkit::Alignment::Type arg2 ; - - arg1 = (Dali::Toolkit::Alignment *)jarg1; - arg2 = (Dali::Toolkit::Alignment::Type)jarg2; - { - try { - (arg1)->SetAlignmentType(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) { - int jresult ; - Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ; - Dali::Toolkit::Alignment::Type result; - - arg1 = (Dali::Toolkit::Alignment *)jarg1; - { - try { - result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) { - Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ; - Dali::Toolkit::Alignment::Scaling arg2 ; - - arg1 = (Dali::Toolkit::Alignment *)jarg1; - arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2; - { - try { - (arg1)->SetScaling(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) { - int jresult ; - Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ; - Dali::Toolkit::Alignment::Scaling result; - - arg1 = (Dali::Toolkit::Alignment *)jarg1; - { - try { - result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) { - Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ; - Dali::Toolkit::Alignment::Padding *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Alignment *)jarg1; - arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0); - return ; - } - { - try { - (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) { - void * jresult ; - Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ; - Dali::Toolkit::Alignment::Padding *result = 0 ; - - arg1 = (Dali::Toolkit::Alignment *)jarg1; - { - try { - result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ; - Dali::Toolkit::Alignment *arg2 = 0 ; - Dali::Toolkit::Alignment *result = 0 ; - - arg1 = (Dali::Toolkit::Alignment *)jarg1; - arg2 = (Dali::Toolkit::Alignment *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() { - void * jresult ; - Dali::Toolkit::FlexContainer::Property *result = 0 ; - - { - try { - result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) { - Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ; - - arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() { - void * jresult ; - Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ; - - { - try { - result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) { - Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ; - - arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() { - void * jresult ; - Dali::Toolkit::FlexContainer *result = 0 ; - - { - try { - result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::FlexContainer *arg1 = 0 ; - Dali::Toolkit::FlexContainer *result = 0 ; - - arg1 = (Dali::Toolkit::FlexContainer *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ; - Dali::Toolkit::FlexContainer *arg2 = 0 ; - Dali::Toolkit::FlexContainer *result = 0 ; - - arg1 = (Dali::Toolkit::FlexContainer *)jarg1; - arg2 = (Dali::Toolkit::FlexContainer *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) { - Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ; - - arg1 = (Dali::Toolkit::FlexContainer *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() { - void * jresult ; - Dali::Toolkit::FlexContainer result; - - { - try { - result = Dali::Toolkit::FlexContainer::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::FlexContainer 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::FlexContainer::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result); - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ImageView::Property::IMAGE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() { - void * jresult ; - Dali::Toolkit::ImageView::Property *result = 0 ; - - { - try { - result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) { - Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ; - - arg1 = (Dali::Toolkit::ImageView::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() { - void * jresult ; - Dali::Toolkit::ImageView *result = 0 ; - - { - try { - result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() { - void * jresult ; - Dali::Toolkit::ImageView result; - - { - try { - result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::Toolkit::ImageView result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - { - try { - result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::ImageDimensions arg2 ; - Dali::ImageDimensions *argp2 ; - Dali::Toolkit::ImageView result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - argp2 = (Dali::ImageDimensions *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = Dali::Toolkit::ImageView::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) { - Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ; - - arg1 = (Dali::Toolkit::ImageView *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::ImageView *arg1 = 0 ; - Dali::Toolkit::ImageView *result = 0 ; - - arg1 = (Dali::Toolkit::ImageView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ; - Dali::Toolkit::ImageView *arg2 = 0 ; - Dali::Toolkit::ImageView *result = 0 ; - - arg1 = (Dali::Toolkit::ImageView *)jarg1; - arg2 = (Dali::Toolkit::ImageView *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::ImageView 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::ImageView::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) { - Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::Toolkit::ImageView *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - (arg1)->SetImage((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - - - //argout typemap for const std::string& - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) { - Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ; - std::string *arg2 = 0 ; - Dali::ImageDimensions arg3 ; - Dali::ImageDimensions *argp3 ; - - arg1 = (Dali::Toolkit::ImageView *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - argp3 = (Dali::ImageDimensions *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return ; - } - arg3 = *argp3; - { - try { - (arg1)->SetImage((std::string const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - - - //argout typemap for const std::string& - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() { - void * jresult ; - Dali::Toolkit::ScrollBar::Property *result = 0 ; - - { - try { - result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) { - Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ; - - arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() { - void * jresult ; - Dali::Toolkit::ScrollBar *result = 0 ; - - { - try { - result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::ScrollBar *arg1 = 0 ; - Dali::Toolkit::ScrollBar *result = 0 ; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - Dali::Toolkit::ScrollBar *arg2 = 0 ; - Dali::Toolkit::ScrollBar *result = 0 ; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - arg2 = (Dali::Toolkit::ScrollBar *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) { - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) { - void * jresult ; - Dali::Toolkit::ScrollBar::Direction arg1 ; - Dali::Toolkit::ScrollBar result; - - arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1; - { - try { - result = Dali::Toolkit::ScrollBar::New(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() { - void * jresult ; - Dali::Toolkit::ScrollBar result; - - { - try { - result = Dali::Toolkit::ScrollBar::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::ScrollBar 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::ScrollBar::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) { - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - Dali::Handle arg2 ; - Dali::Property::Index arg3 ; - Dali::Property::Index arg4 ; - Dali::Property::Index arg5 ; - Dali::Property::Index arg6 ; - Dali::Handle *argp2 ; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - argp2 = (Dali::Handle *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::Property::Index)jarg3; - arg4 = (Dali::Property::Index)jarg4; - arg5 = (Dali::Property::Index)jarg5; - arg6 = (Dali::Property::Index)jarg6; - { - try { - (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetScrollIndicator(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) { - void * jresult ; - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - Dali::Actor result; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - { - try { - result = (arg1)->GetScrollIndicator(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0); - return ; - } - { - try { - (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) { - void * jresult ; - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - { - try { - jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)(((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals())); - } CALL_CATCH_EXCEPTION(0); - } - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) { - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - Dali::Toolkit::ScrollBar::Direction arg2 ; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2; - { - try { - (arg1)->SetScrollDirection(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) { - int jresult ; - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - Dali::Toolkit::ScrollBar::Direction result; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - { - try { - result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) { - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2; - { - try { - (arg1)->SetIndicatorHeightPolicy(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) { - int jresult ; - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - { - try { - result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) { - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetIndicatorFixedHeight(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) { - float jresult ; - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - { - try { - result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) { - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetIndicatorShowDuration(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) { - float jresult ; - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - { - try { - result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) { - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetIndicatorHideDuration(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) { - float jresult ; - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - { - try { - result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) { - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - { - try { - (arg1)->ShowIndicator(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) { - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - { - try { - (arg1)->HideIndicator(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - { - try { - result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ; - Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::ScrollBar *)jarg1; - { - try { - result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() { - void * jresult ; - Dali::Toolkit::Scrollable::Property *result = 0 ; - - { - try { - result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) { - Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ; - - arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() { - void * jresult ; - Dali::Toolkit::Scrollable *result = 0 ; - - { - try { - result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::Scrollable *arg1 = 0 ; - Dali::Toolkit::Scrollable *result = 0 ; - - arg1 = (Dali::Toolkit::Scrollable *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; - Dali::Toolkit::Scrollable *arg2 = 0 ; - Dali::Toolkit::Scrollable *result = 0 ; - - arg1 = (Dali::Toolkit::Scrollable *)jarg1; - arg2 = (Dali::Toolkit::Scrollable *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) { - Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; - - arg1 = (Dali::Toolkit::Scrollable *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::Scrollable 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::Scrollable::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result); - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) { - bool jresult ; - Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::Scrollable *)jarg1; - { - try { - result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, bool jarg2) { - Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; - bool arg2 ; - - arg1 = (Dali::Toolkit::Scrollable *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - (arg1)->SetOvershootEnabled(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) { - Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; - Dali::Vector4 *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Scrollable *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) { - void * jresult ; - Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; - Dali::Vector4 result; - - arg1 = (Dali::Toolkit::Scrollable *)jarg1; - { - try { - result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) { - Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::Scrollable *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetOvershootAnimationSpeed(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) { - float jresult ; - Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; - float result; - - arg1 = (Dali::Toolkit::Scrollable *)jarg1; - { - try { - result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; - Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::Scrollable *)jarg1; - { - try { - result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; - Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::Scrollable *)jarg1; - { - try { - result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ; - Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::Scrollable *)jarg1; - { - try { - result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) { - bool jresult ; - Dali::Toolkit::ControlOrientation::Type arg1 ; - bool result; - - arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1; - { - try { - result = (bool)Dali::Toolkit::IsVertical(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) { - bool jresult ; - Dali::Toolkit::ControlOrientation::Type arg1 ; - bool result; - - arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1; - { - try { - result = (bool)Dali::Toolkit::IsHorizontal(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) { - void * jresult ; - unsigned int arg1 ; - unsigned int arg2 ; - Dali::Toolkit::ItemRange *result = 0 ; - - arg1 = (unsigned int)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::ItemRange *arg1 = 0 ; - Dali::Toolkit::ItemRange *result = 0 ; - - arg1 = (Dali::Toolkit::ItemRange *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ; - Dali::Toolkit::ItemRange *arg2 = 0 ; - Dali::Toolkit::ItemRange *result = 0 ; - - arg1 = (Dali::Toolkit::ItemRange *)jarg1; - arg2 = (Dali::Toolkit::ItemRange *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) { - bool jresult ; - Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ; - unsigned int arg2 ; - bool result; - - arg1 = (Dali::Toolkit::ItemRange *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = (bool)(arg1)->Within(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ; - Dali::Toolkit::ItemRange *arg2 = 0 ; - SwigValueWrapper< Dali::Toolkit::ItemRange > result; - - arg1 = (Dali::Toolkit::ItemRange *)jarg1; - arg2 = (Dali::Toolkit::ItemRange *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0); - return 0; - } - { - try { - result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) { - Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Toolkit::ItemRange *)jarg1; - arg2 = (unsigned int)jarg2; - if (arg1) (arg1)->begin = arg2; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::ItemRange *)jarg1; - result = (unsigned int) ((arg1)->begin); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) { - Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Toolkit::ItemRange *)jarg1; - arg2 = (unsigned int)jarg2; - if (arg1) (arg1)->end = arg2; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::ItemRange *)jarg1; - result = (unsigned int) ((arg1)->end); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) { - Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ; - - arg1 = (Dali::Toolkit::ItemRange *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) { - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) { - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - Dali::Toolkit::ControlOrientation::Type arg2 ; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2; - { - try { - (arg1)->SetOrientation(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) { - int jresult ; - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - Dali::Toolkit::ControlOrientation::Type result; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - { - try { - result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) { - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - Dali::Property::Map *arg2 = 0 ; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - arg2 = (Dali::Property::Map *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); - return ; - } - { - try { - (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) { - void * jresult ; - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - Dali::Property::Map result; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - { - try { - result = (arg1)->GetLayoutProperties(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Property::Map((const Dali::Property::Map &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) { - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - unsigned int arg2 ; - Dali::Vector3 *arg3 = 0 ; - Dali::Vector3 *arg4 = 0 ; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (Dali::Vector3 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - arg4 = (Dali::Vector3 *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); - return ; - } - { - try { - ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) { - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - Dali::Vector3 *arg2 = 0 ; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetItemSize((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) { - float jresult ; - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - unsigned int arg2 ; - Dali::Vector3 arg3 ; - Dali::Vector3 *argp3 ; - float result; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - arg2 = (unsigned int)jarg2; - argp3 = (Dali::Vector3 *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0); - return 0; - } - arg3 = *argp3; - { - try { - result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) { - float jresult ; - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - float arg2 ; - float result; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - arg2 = (float)jarg2; - { - try { - result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) { - float jresult ; - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - unsigned int arg2 ; - float result; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) { - void * jresult ; - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - float arg2 ; - Dali::Vector3 arg3 ; - Dali::Vector3 *argp3 ; - SwigValueWrapper< Dali::Toolkit::ItemRange > result; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - arg2 = (float)jarg2; - argp3 = (Dali::Vector3 *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0); - return 0; - } - arg3 = *argp3; - { - try { - result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result); - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) { - float jresult ; - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - int arg2 ; - float arg3 ; - Dali::Vector3 *arg4 = 0 ; - float result; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - arg2 = (int)jarg2; - arg3 = (float)jarg3; - arg4 = (Dali::Vector3 *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) { - unsigned int jresult ; - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - Dali::Vector3 arg2 ; - Dali::Vector3 *argp2 ; - unsigned int result; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - argp2 = (Dali::Vector3 *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) { - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - unsigned int arg2 ; - Dali::Vector3 *arg3 = 0 ; - Dali::Vector3 *arg4 = 0 ; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (Dali::Vector3 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - arg4 = (Dali::Vector3 *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); - return ; - } - { - try { - ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) { - void * jresult ; - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - Dali::Degree result; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - { - try { - result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Degree((const Dali::Degree &)result); - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) { - float jresult ; - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - { - try { - result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) { - float jresult ; - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - { - try { - result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) { - float jresult ; - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - { - try { - result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, bool jarg5) { - int jresult ; - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - int arg2 ; - int arg3 ; - Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ; - bool arg5 ; - int result; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - arg2 = (int)jarg2; - arg3 = (int)jarg3; - arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4; - arg5 = jarg5 ? true : false; - { - try { - result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) { - float jresult ; - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - { - try { - result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) { - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - Dali::Actor *arg2 = 0 ; - int arg3 ; - Dali::Vector3 *arg4 = 0 ; - Dali::Actor *arg5 = 0 ; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - arg2 = (Dali::Actor *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); - return ; - } - arg3 = (int)jarg3; - arg4 = (Dali::Vector3 *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - arg5 = (Dali::Actor *)jarg5; - if (!arg5) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); - return ; - } - { - try { - (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) { - void * jresult ; - Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ; - int arg2 ; - float arg3 ; - Dali::Vector3 *arg4 = 0 ; - Dali::Vector3 result; - - arg1 = (Dali::Toolkit::ItemLayout *)jarg1; - arg2 = (int)jarg2; - arg3 = (float)jarg3; - arg4 = (Dali::Vector3 *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try { - result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) { - void * jresult ; - Dali::Toolkit::DefaultItemLayout::Type arg1 ; - SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result; - - arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1; - { - try { - result = Dali::Toolkit::DefaultItemLayout::New(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) { - Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ; - - arg1 = (Dali::Toolkit::ItemFactory *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::ItemFactory *)jarg1; - { - try { - result = (unsigned int)(arg1)->GetNumberOfItems(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) { - void * jresult ; - Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ; - unsigned int arg2 ; - Dali::Actor result; - - arg1 = (Dali::Toolkit::ItemFactory *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = (arg1)->NewItem(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) { - Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ; - unsigned int arg2 ; - Dali::Actor arg3 ; - Dali::Actor *argp3 ; - - arg1 = (Dali::Toolkit::ItemFactory *)jarg1; - arg2 = (unsigned int)jarg2; - argp3 = (Dali::Actor *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg3 = *argp3; - { - try { - (arg1)->ItemReleased(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) { - Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ; - unsigned int arg2 ; - Dali::Actor arg3 ; - Dali::Actor *argp3 ; - - arg1 = (Dali::Toolkit::ItemFactory *)jarg1; - arg2 = (unsigned int)jarg2; - argp3 = (Dali::Actor *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg3 = *argp3; - { - try { - (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() { - void * jresult ; - Dali::Toolkit::ItemFactory *result = 0 ; - - { - try { - result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_director_connect(void *objarg, SwigDirector_ItemFactory::SWIG_Callback0_t callback0, SwigDirector_ItemFactory::SWIG_Callback1_t callback1, SwigDirector_ItemFactory::SWIG_Callback2_t callback2) { - Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg; - SwigDirector_ItemFactory *director = dynamic_cast(obj); - if (director) { - director->swig_connect_director(callback0, callback1, callback2); - } -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() { - void * jresult ; - Dali::Toolkit::ItemView::Property *result = 0 ; - - { - try { - result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) { - Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ; - - arg1 = (Dali::Toolkit::ItemView::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() { - void * jresult ; - Dali::Toolkit::ItemView *result = 0 ; - - { - try { - result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::ItemView *arg1 = 0 ; - Dali::Toolkit::ItemView *result = 0 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - Dali::Toolkit::ItemView *arg2 = 0 ; - Dali::Toolkit::ItemView *result = 0 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (Dali::Toolkit::ItemView *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) { - void * jresult ; - Dali::Toolkit::ItemFactory *arg1 = 0 ; - Dali::Toolkit::ItemView result; - - arg1 = (Dali::Toolkit::ItemFactory *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0); - return 0; - } - { - try { - result = Dali::Toolkit::ItemView::New(*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::ItemView 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::ItemView::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result); - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - { - try { - result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - Dali::Toolkit::ItemLayout *arg2 = 0 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (Dali::Toolkit::ItemLayout *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0); - return ; - } - { - try { - (arg1)->AddLayout(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - (arg1)->RemoveLayout(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) { - void * jresult ; - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - unsigned int arg2 ; - SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) { - void * jresult ; - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - { - try { - result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result); - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) { - float jresult ; - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - Dali::Toolkit::ItemId arg2 ; - float result; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (Dali::Toolkit::ItemId)jarg2; - { - try { - result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - unsigned int arg2 ; - Dali::Vector3 arg3 ; - float arg4 ; - Dali::Vector3 *argp3 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (unsigned int)jarg2; - argp3 = (Dali::Vector3 *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0); - return ; - } - arg3 = *argp3; - arg4 = (float)jarg4; - { - try { - (arg1)->ActivateLayout(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - { - try { - (arg1)->DeactivateCurrentLayout(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetMinimumSwipeSpeed(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) { - float jresult ; - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - { - try { - result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetMinimumSwipeDistance(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) { - float jresult ; - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - { - try { - result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetWheelScrollDistanceStep(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) { - float jresult ; - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - { - try { - result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, bool jarg2) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - bool arg2 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - (arg1)->SetAnchoring(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - -//// ========================= end of part 3 ============================= - -//// ========================== start part 4 =============================== - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) { - bool jresult ; - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - { - try { - result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetAnchoringDuration(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) { - float jresult ; - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - { - try { - result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - Dali::Toolkit::ItemId arg2 ; - float arg3 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (Dali::Toolkit::ItemId)jarg2; - arg3 = (float)jarg3; - { - try { - (arg1)->ScrollToItem(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetRefreshInterval(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) { - float jresult ; - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - { - try { - result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - { - try { - (arg1)->Refresh(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) { - void * jresult ; - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - Dali::Toolkit::ItemId arg2 ; - Dali::Actor result; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (Dali::Toolkit::ItemId)jarg2; - { - try { - result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) { - unsigned int jresult ; - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - Dali::Toolkit::ItemId result; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - Dali::Toolkit::Item arg2 ; - float arg3 ; - Dali::Toolkit::Item *argp2 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - argp2 = (Dali::Toolkit::Item *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0); - return ; - } - arg2 = *argp2; - arg3 = (float)jarg3; - { - try { - (arg1)->InsertItem(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - Dali::Toolkit::ItemContainer *arg2 = 0 ; - float arg3 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (Dali::Toolkit::ItemContainer *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0); - return ; - } - arg3 = (float)jarg3; - { - try { - (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - Dali::Toolkit::ItemId arg2 ; - float arg3 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (Dali::Toolkit::ItemId)jarg2; - arg3 = (float)jarg3; - { - try { - (arg1)->RemoveItem(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - Dali::Toolkit::ItemIdContainer *arg2 = 0 ; - float arg3 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0); - return ; - } - arg3 = (float)jarg3; - { - try { - (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - Dali::Toolkit::Item arg2 ; - float arg3 ; - Dali::Toolkit::Item *argp2 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - argp2 = (Dali::Toolkit::Item *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0); - return ; - } - arg2 = *argp2; - arg3 = (float)jarg3; - { - try { - (arg1)->ReplaceItem(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - Dali::Toolkit::ItemContainer *arg2 = 0 ; - float arg3 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (Dali::Toolkit::ItemContainer *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0); - return ; - } - arg3 = (float)jarg3; - { - try { - (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - Dali::Vector3 *arg2 = 0 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) { - void * jresult ; - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - Dali::Vector3 result; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - { - try { - result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - Dali::Vector3 *arg2 = 0 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) { - void * jresult ; - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - Dali::Vector3 result; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - { - try { - result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3 &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) { - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - Dali::Toolkit::ItemRange *arg2 = 0 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - arg2 = (Dali::Toolkit::ItemRange *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0); - return ; - } - { - try { - (arg1)->GetItemsRange(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ; - Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::ItemView *)jarg1; - { - try { - result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) { - Dali::Vector3 *arg1 = 0 ; - PropertyInputContainer *arg2 = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); - return ; - } - arg2 = (PropertyInputContainer *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0); - return ; - } - { - try { - Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) { - Dali::Vector3 *arg1 = 0 ; - PropertyInputContainer *arg2 = 0 ; - - arg1 = (Dali::Vector3 *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); - return ; - } - arg2 = (PropertyInputContainer *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0); - return ; - } - { - try { - Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() { - void * jresult ; - Dali::Toolkit::ScrollViewEffect *result = 0 ; - - { - try { - result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) { - Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ; - - arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) { - void * jresult ; - Dali::Path arg1 ; - Dali::Vector3 *arg2 = 0 ; - Dali::Property::Index arg3 ; - Dali::Vector3 *arg4 = 0 ; - unsigned int arg5 ; - Dali::Path *argp1 ; - Dali::Toolkit::ScrollViewPagePathEffect result; - - argp1 = (Dali::Path *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0); - return 0; - } - arg1 = *argp1; - arg2 = (Dali::Vector3 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - arg3 = (Dali::Property::Index)jarg3; - arg4 = (Dali::Vector3 *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - arg5 = (unsigned int)jarg5; - { - try { - result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() { - void * jresult ; - Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ; - - { - try { - result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::ScrollViewPagePathEffect 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::ScrollViewPagePathEffect::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) { - Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ; - Dali::Actor arg2 ; - unsigned int arg3 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - arg3 = (unsigned int)jarg3; - { - try { - (arg1)->ApplyToPage(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) { - Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ; - - arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) { - Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ; - Dali::Toolkit::ClampState arg2 ; - - arg1 = (Dali::Toolkit::ClampState2D *)jarg1; - arg2 = (Dali::Toolkit::ClampState)jarg2; - if (arg1) (arg1)->x = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) { - int jresult ; - Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ; - Dali::Toolkit::ClampState result; - - arg1 = (Dali::Toolkit::ClampState2D *)jarg1; - result = (Dali::Toolkit::ClampState) ((arg1)->x); - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) { - Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ; - Dali::Toolkit::ClampState arg2 ; - - arg1 = (Dali::Toolkit::ClampState2D *)jarg1; - arg2 = (Dali::Toolkit::ClampState)jarg2; - if (arg1) (arg1)->y = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) { - int jresult ; - Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ; - Dali::Toolkit::ClampState result; - - arg1 = (Dali::Toolkit::ClampState2D *)jarg1; - result = (Dali::Toolkit::ClampState) ((arg1)->y); - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() { - void * jresult ; - Dali::Toolkit::ClampState2D *result = 0 ; - - { - try { - result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) { - Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ; - - arg1 = (Dali::Toolkit::ClampState2D *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, bool jarg3) { - void * jresult ; - float arg1 ; - float arg2 ; - bool arg3 ; - Dali::Toolkit::RulerDomain *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - arg3 = jarg3 ? true : false; - { - try { - result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) { - void * jresult ; - float arg1 ; - float arg2 ; - Dali::Toolkit::RulerDomain *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - { - try { - result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) { - Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::RulerDomain *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->min = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) { - float jresult ; - Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; - float result; - - arg1 = (Dali::Toolkit::RulerDomain *)jarg1; - result = (float) ((arg1)->min); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) { - Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::RulerDomain *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->max = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) { - float jresult ; - Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; - float result; - - arg1 = (Dali::Toolkit::RulerDomain *)jarg1; - result = (float) ((arg1)->max); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, bool jarg2) { - Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; - bool arg2 ; - - arg1 = (Dali::Toolkit::RulerDomain *)jarg1; - arg2 = jarg2 ? true : false; - if (arg1) (arg1)->enabled = arg2; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) { - bool jresult ; - Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::RulerDomain *)jarg1; - result = (bool) ((arg1)->enabled); - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) { - float jresult ; - Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; - float arg2 ; - float arg3 ; - float arg4 ; - float result; - - arg1 = (Dali::Toolkit::RulerDomain *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - { - try { - result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) { - float jresult ; - Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; - float arg2 ; - float arg3 ; - float result; - - arg1 = (Dali::Toolkit::RulerDomain *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - { - try { - result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) { - float jresult ; - Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; - float arg2 ; - float result; - - arg1 = (Dali::Toolkit::RulerDomain *)jarg1; - arg2 = (float)jarg2; - { - try { - result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) { - float jresult ; - Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; - float arg2 ; - float arg3 ; - float arg4 ; - Dali::Toolkit::ClampState *arg5 = 0 ; - float result; - - arg1 = (Dali::Toolkit::RulerDomain *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - arg5 = (Dali::Toolkit::ClampState *)jarg5; - if (!arg5) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0); - return 0; - } - { - try { - result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) { - float jresult ; - Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; - float result; - - arg1 = (Dali::Toolkit::RulerDomain *)jarg1; - { - try { - result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) { - Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ; - - arg1 = (Dali::Toolkit::RulerDomain *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) { - float jresult ; - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - float arg2 ; - float arg3 ; - float result; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - { - try { - result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) { - float jresult ; - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - float arg2 ; - float result; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - arg2 = (float)jarg2; - { - try { - result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) { - float jresult ; - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - unsigned int arg2 ; - unsigned int *arg3 = 0 ; - bool arg4 ; - float result; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (unsigned int *)jarg3; - arg4 = jarg4 ? true : false; - { - try { - result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) { - unsigned int jresult ; - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - float arg2 ; - bool arg3 ; - unsigned int result; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - arg2 = (float)jarg2; - arg3 = jarg3 ? true : false; - { - try { - result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - { - try { - result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) { - int jresult ; - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - Dali::Toolkit::Ruler::RulerType result; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - { - try { - result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) { - bool jresult ; - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - { - try { - result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) { - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - { - try { - (arg1)->Enable(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) { - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - { - try { - (arg1)->Disable(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) { - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ; - Dali::Toolkit::RulerDomain *argp2 ; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - argp2 = (Dali::Toolkit::RulerDomain *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetDomain(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) { - void * jresult ; - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - Dali::Toolkit::RulerDomain *result = 0 ; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - { - try { - result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) { - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - { - try { - (arg1)->DisableDomain(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) { - float jresult ; - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - float arg2 ; - float arg3 ; - float arg4 ; - float result; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - { - try { - result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) { - float jresult ; - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - float arg2 ; - float arg3 ; - float result; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - { - try { - result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) { - float jresult ; - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - float arg2 ; - float result; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - arg2 = (float)jarg2; - { - try { - result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) { - float jresult ; - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - float arg2 ; - float arg3 ; - float arg4 ; - Dali::Toolkit::ClampState *arg5 = 0 ; - float result; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - arg5 = (Dali::Toolkit::ClampState *)jarg5; - if (!arg5) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0); - return 0; - } - { - try { - result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) { - float jresult ; - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - float arg2 ; - float arg3 ; - float arg4 ; - float arg5 ; - float result; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - arg5 = (float)jarg5; - { - try { - result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) { - float jresult ; - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - float arg2 ; - float arg3 ; - float arg4 ; - float result; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - { - try { - result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) { - float jresult ; - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - float arg2 ; - float arg3 ; - float result; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - { - try { - result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) { - float jresult ; - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - float arg2 ; - float result; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - arg2 = (float)jarg2; - { - try { - result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) { - float jresult ; - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - float arg2 ; - float arg3 ; - float arg4 ; - float arg5 ; - Dali::Toolkit::ClampState *arg6 = 0 ; - float result; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - arg5 = (float)jarg5; - arg6 = (Dali::Toolkit::ClampState *)jarg6; - if (!arg6) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0); - return 0; - } - { - try { - result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() { - void * jresult ; - Dali::Toolkit::DefaultRuler *result = 0 ; - - { - try { - result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) { - float jresult ; - Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ; - float arg2 ; - float arg3 ; - float result; - - arg1 = (Dali::Toolkit::DefaultRuler *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - { - try { - result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) { - float jresult ; - Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ; - unsigned int arg2 ; - unsigned int *arg3 = 0 ; - bool arg4 ; - float result; - - arg1 = (Dali::Toolkit::DefaultRuler *)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (unsigned int *)jarg3; - arg4 = jarg4 ? true : false; - { - try { - result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) { - unsigned int jresult ; - Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ; - float arg2 ; - bool arg3 ; - unsigned int result; - - arg1 = (Dali::Toolkit::DefaultRuler *)jarg1; - arg2 = (float)jarg2; - arg3 = jarg3 ? true : false; - { - try { - result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::DefaultRuler *)jarg1; - { - try { - result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) { - Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ; - - arg1 = (Dali::Toolkit::DefaultRuler *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) { - void * jresult ; - float arg1 ; - Dali::Toolkit::FixedRuler *result = 0 ; - - arg1 = (float)jarg1; - { - try { - result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() { - void * jresult ; - Dali::Toolkit::FixedRuler *result = 0 ; - - { - try { - result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) { - float jresult ; - Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ; - float arg2 ; - float arg3 ; - float result; - - arg1 = (Dali::Toolkit::FixedRuler *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - { - try { - result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) { - float jresult ; - Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ; - unsigned int arg2 ; - unsigned int *arg3 = 0 ; - bool arg4 ; - float result; - - arg1 = (Dali::Toolkit::FixedRuler *)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (unsigned int *)jarg3; - arg4 = jarg4 ? true : false; - { - try { - result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) { - unsigned int jresult ; - Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ; - float arg2 ; - bool arg3 ; - unsigned int result; - - arg1 = (Dali::Toolkit::FixedRuler *)jarg1; - arg2 = (float)jarg2; - arg3 = jarg3 ? true : false; - { - try { - result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::FixedRuler *)jarg1; - { - try { - result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) { - Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ; - - arg1 = (Dali::Toolkit::FixedRuler *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ; - Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ; - - arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1; - arg2 = (Dali::Toolkit::ClampState2D *)jarg2; - if (arg1) (arg1)->scale = *arg2; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) { - void * jresult ; - Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ; - Dali::Toolkit::ClampState2D *result = 0 ; - - arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1; - result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ; - Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ; - - arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1; - arg2 = (Dali::Toolkit::ClampState2D *)jarg2; - if (arg1) (arg1)->position = *arg2; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) { - void * jresult ; - Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ; - Dali::Toolkit::ClampState2D *result = 0 ; - - arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1; - result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) { - Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ; - Dali::Toolkit::ClampState arg2 ; - - arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1; - arg2 = (Dali::Toolkit::ClampState)jarg2; - if (arg1) (arg1)->rotation = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) { - int jresult ; - Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ; - Dali::Toolkit::ClampState result; - - arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1; - result = (Dali::Toolkit::ClampState) ((arg1)->rotation); - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() { - void * jresult ; - Dali::Toolkit::ScrollView::ClampEvent *result = 0 ; - - { - try { - result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) { - Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ; - - arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) { - Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ; - Dali::Toolkit::SnapType arg2 ; - - arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1; - arg2 = (Dali::Toolkit::SnapType)jarg2; - if (arg1) (arg1)->type = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) { - int jresult ; - Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ; - Dali::Toolkit::SnapType result; - - arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1; - result = (Dali::Toolkit::SnapType) ((arg1)->type); - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ; - Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ; - - arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (arg1) (arg1)->position = *arg2; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) { - void * jresult ; - Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1; - result = (Dali::Vector2 *)& ((arg1)->position); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) { - Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->duration = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) { - float jresult ; - Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1; - result = (float) ((arg1)->duration); - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() { - void * jresult ; - Dali::Toolkit::ScrollView::SnapEvent *result = 0 ; - - { - try { - result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) { - Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ; - - arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::WRAP; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::PANNING; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() { - void * jresult ; - Dali::Toolkit::ScrollView::Property *result = 0 ; - - { - try { - result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) { - Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ; - - arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() { - void * jresult ; - Dali::Toolkit::ScrollView *result = 0 ; - - { - try { - result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::ScrollView *arg1 = 0 ; - Dali::Toolkit::ScrollView *result = 0 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Toolkit::ScrollView *arg2 = 0 ; - Dali::Toolkit::ScrollView *result = 0 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (Dali::Toolkit::ScrollView *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() { - void * jresult ; - Dali::Toolkit::ScrollView result; - - { - try { - result = Dali::Toolkit::ScrollView::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::ScrollView 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::ScrollView::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) { - void * jresult ; - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::AlphaFunction result; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::AlphaFunction arg2 ; - Dali::AlphaFunction *argp2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - argp2 = (Dali::AlphaFunction *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetScrollSnapAlphaFunction(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) { - void * jresult ; - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::AlphaFunction result; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::AlphaFunction arg2 ; - Dali::AlphaFunction *argp2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - argp2 = (Dali::AlphaFunction *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetScrollFlickAlphaFunction(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) { - float jresult ; - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetScrollSnapDuration(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) { - float jresult ; - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetScrollFlickDuration(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Toolkit::RulerPtr arg2 ; - Dali::Toolkit::RulerPtr *argp2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - argp2 = (Dali::Toolkit::RulerPtr *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetRulerX(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Toolkit::RulerPtr arg2 ; - Dali::Toolkit::RulerPtr *argp2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - argp2 = (Dali::Toolkit::RulerPtr *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetRulerY(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, bool jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - bool arg2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - (arg1)->SetScrollSensitive(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - float arg2 ; - float arg3 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - { - try { - (arg1)->SetMaxOvershoot(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::AlphaFunction arg2 ; - Dali::AlphaFunction *argp2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - argp2 = (Dali::AlphaFunction *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetSnapOvershootAlphaFunction(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetSnapOvershootDuration(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, bool jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - bool arg2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - (arg1)->SetActorAutoSnap(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, bool jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - bool arg2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - (arg1)->SetWrapMode(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) { - int jresult ; - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - int result; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - int arg2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (int)jarg2; - { - try { - (arg1)->SetScrollUpdateDistance(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) { - bool jresult ; - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, bool jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - bool arg2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - (arg1)->SetAxisAutoLock(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) { - float jresult ; - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetAxisAutoLockGradient(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) { - float jresult ; - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetFrictionCoefficient(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) { - float jresult ; - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetFlickSpeedCoefficient(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) { - void * jresult ; - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Vector2 *arg2 = 0 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) { - float jresult ; - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetMinimumSpeedForFlick(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) { - float jresult ; - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - float result; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->SetMaxFlickSpeed(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) { - void * jresult ; - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Vector2 arg2 ; - Dali::Vector2 *argp2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - argp2 = (Dali::Vector2 *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetWheelScrollDistanceStep(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) { - void * jresult ; - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Vector2 *arg2 = 0 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - { - try { - (arg1)->ScrollTo((Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Vector2 *arg2 = 0 ; - float arg3 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - arg3 = (float)jarg3; - { - try { - (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Vector2 *arg2 = 0 ; - float arg3 ; - Dali::AlphaFunction arg4 ; - Dali::AlphaFunction *argp4 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - arg3 = (float)jarg3; - argp4 = (Dali::AlphaFunction *)jarg4; - if (!argp4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); - return ; - } - arg4 = *argp4; - { - try { - (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Vector2 *arg2 = 0 ; - float arg3 ; - Dali::Toolkit::DirectionBias arg4 ; - Dali::Toolkit::DirectionBias arg5 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - arg3 = (float)jarg3; - arg4 = (Dali::Toolkit::DirectionBias)jarg4; - arg5 = (Dali::Toolkit::DirectionBias)jarg5; - { - try { - (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Vector2 *arg2 = 0 ; - float arg3 ; - Dali::AlphaFunction arg4 ; - Dali::Toolkit::DirectionBias arg5 ; - Dali::Toolkit::DirectionBias arg6 ; - Dali::AlphaFunction *argp4 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - arg3 = (float)jarg3; - argp4 = (Dali::AlphaFunction *)jarg4; - if (!argp4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0); - return ; - } - arg4 = *argp4; - arg5 = (Dali::Toolkit::DirectionBias)jarg5; - arg6 = (Dali::Toolkit::DirectionBias)jarg6; - { - try { - (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - (arg1)->ScrollTo(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - unsigned int arg2 ; - float arg3 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (float)jarg3; - { - try { - (arg1)->ScrollTo(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - unsigned int arg2 ; - float arg3 ; - Dali::Toolkit::DirectionBias arg4 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (float)jarg3; - arg4 = (Dali::Toolkit::DirectionBias)jarg4; - { - try { - (arg1)->ScrollTo(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Actor *arg2 = 0 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (Dali::Actor *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); - return ; - } - { - try { - (arg1)->ScrollTo(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Actor *arg2 = 0 ; - float arg3 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - arg2 = (Dali::Actor *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); - return ; - } - arg3 = (float)jarg3; - { - try { - (arg1)->ScrollTo(*arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) { - bool jresult ; - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - result = (bool)(arg1)->ScrollToSnapPoint(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Constraint arg2 ; - Dali::Constraint *argp2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - argp2 = (Dali::Constraint *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->ApplyConstraintToChildren(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - (arg1)->RemoveConstraintsFromChildren(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Toolkit::ScrollViewEffect arg2 ; - Dali::Toolkit::ScrollViewEffect *argp2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->ApplyEffect(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Toolkit::ScrollViewEffect arg2 ; - Dali::Toolkit::ScrollViewEffect *argp2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->RemoveEffect(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - (arg1)->RemoveAllEffects(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->BindActor(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->UnbindActor(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Radian arg2 ; - Dali::Radian arg3 ; - Dali::Radian *argp2 ; - Dali::Radian *argp3 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - argp2 = (Dali::Radian *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Radian *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return ; - } - arg3 = *argp3; - { - try { - (arg1)->SetScrollingDirection(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Radian arg2 ; - Dali::Radian *argp2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - argp2 = (Dali::Radian *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetScrollingDirection(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) { - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Radian arg2 ; - Dali::Radian *argp2 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - argp2 = (Dali::Radian *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->RemoveScrollingDirection(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ; - Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::ScrollView *)jarg1; - { - try { - result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TableView::Property::ROWS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TableView::Property::COLUMNS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() { - void * jresult ; - Dali::Toolkit::TableView::Property *result = 0 ; - - { - try { - result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) { - Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ; - - arg1 = (Dali::Toolkit::TableView::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() { - void * jresult ; - Dali::Toolkit::TableView::ChildProperty *result = 0 ; - - { - try { - result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) { - Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ; - - arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) { - void * jresult ; - unsigned int arg1 ; - unsigned int arg2 ; - unsigned int arg3 ; - unsigned int arg4 ; - Dali::Toolkit::TableView::CellPosition *result = 0 ; - - arg1 = (unsigned int)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (unsigned int)jarg3; - arg4 = (unsigned int)jarg4; - { - try { - result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) { - void * jresult ; - unsigned int arg1 ; - unsigned int arg2 ; - unsigned int arg3 ; - Dali::Toolkit::TableView::CellPosition *result = 0 ; - - arg1 = (unsigned int)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (unsigned int)jarg3; - { - try { - result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) { - void * jresult ; - unsigned int arg1 ; - unsigned int arg2 ; - Dali::Toolkit::TableView::CellPosition *result = 0 ; - - arg1 = (unsigned int)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) { - void * jresult ; - unsigned int arg1 ; - Dali::Toolkit::TableView::CellPosition *result = 0 ; - - arg1 = (unsigned int)jarg1; - { - try { - result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() { - void * jresult ; - Dali::Toolkit::TableView::CellPosition *result = 0 ; - - { - try { - result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) { - Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1; - arg2 = (unsigned int)jarg2; - if (arg1) (arg1)->rowIndex = arg2; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1; - result = (unsigned int) ((arg1)->rowIndex); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) { - Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1; - arg2 = (unsigned int)jarg2; - if (arg1) (arg1)->columnIndex = arg2; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1; - result = (unsigned int) ((arg1)->columnIndex); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) { - Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1; - arg2 = (unsigned int)jarg2; - if (arg1) (arg1)->rowSpan = arg2; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1; - result = (unsigned int) ((arg1)->rowSpan); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) { - Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1; - arg2 = (unsigned int)jarg2; - if (arg1) (arg1)->columnSpan = arg2; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1; - result = (unsigned int) ((arg1)->columnSpan); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) { - Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ; - - arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() { - void * jresult ; - Dali::Toolkit::TableView *result = 0 ; - - { - try { - result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::TableView *arg1 = 0 ; - Dali::Toolkit::TableView *result = 0 ; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - Dali::Toolkit::TableView *arg2 = 0 ; - Dali::Toolkit::TableView *result = 0 ; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (Dali::Toolkit::TableView *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) { - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) { - void * jresult ; - unsigned int arg1 ; - unsigned int arg2 ; - Dali::Toolkit::TableView result; - - arg1 = (unsigned int)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = Dali::Toolkit::TableView::New(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::TableView 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::TableView::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result); - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) { - bool jresult ; - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - Dali::Actor arg2 ; - Dali::Toolkit::TableView::CellPosition arg3 ; - Dali::Actor *argp2 ; - Dali::Toolkit::TableView::CellPosition *argp3 ; - bool result; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg2 = *argp2; - argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0); - return 0; - } - arg3 = *argp3; - { - try { - result = (bool)(arg1)->AddChild(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - Dali::Toolkit::TableView::CellPosition arg2 ; - Dali::Toolkit::TableView::CellPosition *argp2 ; - Dali::Actor result; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (arg1)->GetChildAt(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - Dali::Toolkit::TableView::CellPosition arg2 ; - Dali::Toolkit::TableView::CellPosition *argp2 ; - Dali::Actor result; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (arg1)->RemoveChildAt(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) { - bool jresult ; - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - Dali::Actor arg2 ; - Dali::Toolkit::TableView::CellPosition *arg3 = 0 ; - Dali::Actor *argp2 ; - bool result; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg2 = *argp2; - arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0); - return 0; - } - { - try { - result = (bool)(arg1)->FindChildPosition(arg2,*arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) { - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - (arg1)->InsertRow(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) { - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - (arg1)->DeleteRow(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) { - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - std::vector< Dali::Actor > *arg3 = 0 ; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (std::vector< Dali::Actor > *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0); - return ; - } - { - try { - (arg1)->DeleteRow(arg2,*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) { - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - (arg1)->InsertColumn(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) { - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - (arg1)->DeleteColumn(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) { - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - std::vector< Dali::Actor > *arg3 = 0 ; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (std::vector< Dali::Actor > *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0); - return ; - } - { - try { - (arg1)->DeleteColumn(arg2,*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) { - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - unsigned int arg3 ; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (unsigned int)jarg3; - { - try { - (arg1)->Resize(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) { - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - unsigned int arg3 ; - std::vector< Dali::Actor > *arg4 = 0 ; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (unsigned int)jarg3; - arg4 = (std::vector< Dali::Actor > *)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0); - return ; - } - { - try { - (arg1)->Resize(arg2,arg3,*arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) { - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - Dali::Size arg2 ; - Dali::Size *argp2 ; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - argp2 = (Dali::Size *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetCellPadding(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) { - void * jresult ; - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - Dali::Size result; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - { - try { - result = (arg1)->GetCellPadding(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Size((const Dali::Size &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) { - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - (arg1)->SetFitHeight(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) { - bool jresult ; - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - bool result; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) { - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - (arg1)->SetFitWidth(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) { - bool jresult ; - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - bool result; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) { - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - float arg3 ; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (float)jarg3; - { - try { - (arg1)->SetFixedHeight(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) { - float jresult ; - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - float result; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) { - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - float arg3 ; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (float)jarg3; - { - try { - (arg1)->SetRelativeHeight(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) { - float jresult ; - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - float result; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) { - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - float arg3 ; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (float)jarg3; - { - try { - (arg1)->SetFixedWidth(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) { - float jresult ; - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - float result; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) { - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - float arg3 ; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (float)jarg3; - { - try { - (arg1)->SetRelativeWidth(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) { - float jresult ; - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int arg2 ; - float result; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - { - try { - result = (unsigned int)(arg1)->GetRows(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - { - try { - result = (unsigned int)(arg1)->GetColumns(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) { - Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ; - Dali::Toolkit::TableView::CellPosition arg2 ; - Dali::HorizontalAlignment::Type arg3 ; - Dali::VerticalAlignment::Type arg4 ; - Dali::Toolkit::TableView::CellPosition *argp2 ; - - arg1 = (Dali::Toolkit::TableView *)jarg1; - argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::HorizontalAlignment::Type)jarg3; - arg4 = (Dali::VerticalAlignment::Type)jarg4; - { - try { - (arg1)->SetCellAlignment(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() { - unsigned int jresult ; - unsigned int result; - - result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND; - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::TEXT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::SHADOW; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() { - void * jresult ; - Dali::Toolkit::TextLabel::Property *result = 0 ; - - { - try { - result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) { - Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ; - - arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() { - void * jresult ; - Dali::Toolkit::TextLabel result; - - { - try { - result = Dali::Toolkit::TextLabel::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * text) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::Toolkit::TextLabel result; - - if (!text) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(text); - arg1 = &arg1_str; - { - try { - result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New_With_Style(bool hasStyle) { - void * jresult ; - Dali::Toolkit::TextLabel result; - - { - try { - if (hasStyle) { - result = Dali::Toolkit::TextLabel::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS); - } else { - result = Dali::Toolkit::TextLabel::New(); - } - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New_With_String_Style(char * text, bool hasStyle) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::Toolkit::TextLabel result; - - if (!text) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(text); - arg1 = &arg1_str; - { - try { - if (hasStyle) { - result = Dali::Toolkit::TextLabel::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, (std::string const &)*arg1); - } else { - result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1); - } - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() { - void * jresult ; - Dali::Toolkit::TextLabel *result = 0 ; - - { - try { - result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::TextLabel *arg1 = 0 ; - Dali::Toolkit::TextLabel *result = 0 ; - - arg1 = (Dali::Toolkit::TextLabel *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ; - Dali::Toolkit::TextLabel *arg2 = 0 ; - Dali::Toolkit::TextLabel *result = 0 ; - - arg1 = (Dali::Toolkit::TextLabel *)jarg1; - arg2 = (Dali::Toolkit::TextLabel *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) { - Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ; - - arg1 = (Dali::Toolkit::TextLabel *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::TextLabel 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::TextLabel::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() { - void * jresult ; - Dali::Toolkit::AccessibilityManager *result = 0 ; - - { - try { - result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) { - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() { - void * jresult ; - Dali::Toolkit::AccessibilityManager result; - - { - try { - result = Dali::Toolkit::AccessibilityManager::Get(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) { - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Actor arg2 ; - Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ; - std::string *arg4 = 0 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3; - if (!jarg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg4_str(jarg4); - arg4 = &arg4_str; - { - try { - (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4); - } CALL_CATCH_EXCEPTION(); - } - - - //argout typemap for const std::string& - -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) { - char * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Actor arg2 ; - Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ; - Dali::Actor *argp2 ; - std::string result; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg2 = *argp2; - arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3; - { - try { - result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback((&result)->c_str()); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) { - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Actor arg2 ; - unsigned int arg3 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - arg3 = (unsigned int)jarg3; - { - try { - (arg1)->SetFocusOrder(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) { - unsigned int jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - unsigned int result; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - unsigned int arg2 ; - Dali::Actor result; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = (arg1)->GetActorByFocusOrder(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - bool result; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (bool)(arg1)->SetCurrentFocusActor(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Actor result; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (arg1)->GetCurrentFocusActor(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Actor result; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (arg1)->GetCurrentFocusGroup(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (unsigned int)(arg1)->GetCurrentFocusOrder(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) { - bool jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (bool)(arg1)->MoveFocusForward(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) { - bool jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (bool)(arg1)->MoveFocusBackward(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) { - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - (arg1)->ClearFocus(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) { - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - (arg1)->Reset(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, bool jarg3) { - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Actor arg2 ; - bool arg3 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - arg3 = jarg3 ? true : false; - { - try { - (arg1)->SetFocusGroup(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - bool result; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, bool jarg2) { - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - bool arg2 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - (arg1)->SetGroupMode(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) { - bool jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, bool jarg2) { - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - bool arg2 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - (arg1)->SetWrapMode(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) { - bool jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) { - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetFocusIndicatorActor(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Actor result; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (arg1)->GetFocusIndicatorActor(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - Dali::Actor result; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (arg1)->GetFocusGroup(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -GENERATE_SIGNAL(Dali::Toolkit::AccessibilityManager*, void(*)(Dali::Actor), Dali_AccessibilityManager, FocusedActorActivatedSignal) -// CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal_Connect -// CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal_Disconnect - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ; - Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1; - { - try { - result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() { - void * jresult ; - Dali::Toolkit::StyleManager *result = 0 ; - - { - try { - result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) { - Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ; - - arg1 = (Dali::Toolkit::StyleManager *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() { - void * jresult ; - Dali::Toolkit::StyleManager result; - - { - try { - result = Dali::Toolkit::StyleManager::Get(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) { - Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::Toolkit::StyleManager *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - (arg1)->ApplyTheme((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - - - //argout typemap for const std::string& - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) { - Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ; - - arg1 = (Dali::Toolkit::StyleManager *)jarg1; - { - try { - (arg1)->ApplyDefaultTheme(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) { - Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ; - std::string *arg2 = 0 ; - Dali::Property::Value *arg3 = 0 ; - - arg1 = (Dali::Toolkit::StyleManager *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Property::Value *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); - return ; - } - { - try { - (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - - - //argout typemap for const std::string& - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) { - bool jresult ; - Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ; - std::string *arg2 = 0 ; - Dali::Property::Value *arg3 = 0 ; - bool result; - - arg1 = (Dali::Toolkit::StyleManager *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Property::Value *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0); - return 0; - } - { - try { - result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) { - Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ; - Dali::Toolkit::Control arg2 ; - std::string *arg3 = 0 ; - std::string *arg4 = 0 ; - Dali::Toolkit::Control *argp2 ; - - arg1 = (Dali::Toolkit::StyleManager *)jarg1; - argp2 = (Dali::Toolkit::Control *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0); - return ; - } - arg2 = *argp2; - if (!jarg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg3_str(jarg3); - arg3 = &arg3_str; - if (!jarg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg4_str(jarg4); - arg4 = &arg4_str; - { - try { - (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4); - } CALL_CATCH_EXCEPTION(); - } - - - //argout typemap for const std::string& - - - //argout typemap for const std::string& - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ; - Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::StyleManager *)jarg1; - { - try { - result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::VideoView::Property::VIDEO; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::VideoView::Property::LOOPING; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::VideoView::Property::MUTED; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::VideoView::Property::VOLUME; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() { - int result; - - result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY; - - return result; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() { - void * jresult ; - Dali::Toolkit::VideoView::Property *result = 0 ; - - { - try { - result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) { - Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ; - - arg1 = (Dali::Toolkit::VideoView::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() { - void * jresult ; - Dali::Toolkit::VideoView result; - - { - try { - result = Dali::Toolkit::VideoView::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::Toolkit::VideoView result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - { - try { - result = Dali::Toolkit::VideoView::New((std::string const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) { - void * jresult ; - Dali::Toolkit::VideoView result; - { - try { - result = Dali::Toolkit::VideoView::New(swCodec); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::Toolkit::VideoView result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - { - try { - result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result); - - //argout typemap for const std::string& - - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_4(unsigned int jarg1) { - void * jresult ; - Dali::VideoSyncMode syncMode; - Dali::Toolkit::VideoView result; - - syncMode = static_cast(jarg1); - - { - try { - result = Dali::Toolkit::DevelVideoView::New(syncMode); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result); - - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() { - void * jresult ; - Dali::Toolkit::VideoView *result = 0 ; - - { - try { - result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) { - Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ; - - arg1 = (Dali::Toolkit::VideoView *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::VideoView *arg1 = 0 ; - Dali::Toolkit::VideoView *result = 0 ; - - arg1 = (Dali::Toolkit::VideoView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ; - Dali::Toolkit::VideoView *arg2 = 0 ; - Dali::Toolkit::VideoView *result = 0 ; - - arg1 = (Dali::Toolkit::VideoView *)jarg1; - arg2 = (Dali::Toolkit::VideoView *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::VideoView 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::VideoView::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) { - Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ; - - arg1 = (Dali::Toolkit::VideoView *)jarg1; - { - try { - (arg1)->Play(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) { - Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ; - - arg1 = (Dali::Toolkit::VideoView *)jarg1; - { - try { - (arg1)->Pause(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) { - Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ; - - arg1 = (Dali::Toolkit::VideoView *)jarg1; - { - try { - (arg1)->Stop(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) { - Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ; - int arg2 ; - - arg1 = (Dali::Toolkit::VideoView *)jarg1; - arg2 = (int)jarg2; - { - try { - (arg1)->Forward(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) { - Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ; - int arg2 ; - - arg1 = (Dali::Toolkit::VideoView *)jarg1; - arg2 = (int)jarg2; - { - try { - (arg1)->Backward(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ; - Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::VideoView *)jarg1; - { - try { - result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle(void * jarg1) -{ - Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1; - if( arg1 == nullptr ) - { - DALI_LOG_ERROR("VideoView is nullptr!"); - return nullptr; - } - void * ret = nullptr; - { - try{ - - Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 ); - ret = Dali::AnyCast< void * >( result ); - - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_New__SWIG_0(void * jarg1, int jarg2) { - void * jresult ; - Dali::Toolkit::CameraView result; - - Dali::Any arg1(jarg1); - Dali::Toolkit::CameraView::DisplayType arg2 = static_cast(jarg2); - { - try { - result = Dali::Toolkit::CameraView::New(arg1, arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::CameraView((const Dali::Toolkit::CameraView &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraView__SWIG_0() { - void * jresult ; - Dali::Toolkit::CameraView *result = 0 ; - - { - try { - result = (Dali::Toolkit::CameraView *)new Dali::Toolkit::CameraView(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraView(void * jarg1) { - Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ; - - arg1 = (Dali::Toolkit::CameraView *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraView__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::CameraView *arg1 = 0 ; - Dali::Toolkit::CameraView *result = 0 ; - - arg1 = (Dali::Toolkit::CameraView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CameraView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::CameraView *)new Dali::Toolkit::CameraView((Dali::Toolkit::CameraView const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ; - Dali::Toolkit::CameraView *arg2 = 0 ; - Dali::Toolkit::CameraView *result = 0 ; - - arg1 = (Dali::Toolkit::CameraView *)jarg1; - arg2 = (Dali::Toolkit::CameraView *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CameraView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::CameraView *) &(arg1)->operator =((Dali::Toolkit::CameraView const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraView_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::CameraView 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::CameraView::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::CameraView((const Dali::Toolkit::CameraView &)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraView_Update(void * jarg1) { - Dali::Toolkit::CameraView *arg1 = (Dali::Toolkit::CameraView *) 0 ; - - arg1 = (Dali::Toolkit::CameraView *)jarg1; - { - try { - (arg1)->Update(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_PlayAnimation(void * jarg1, void * jarg2) -{ - Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView*)jarg1; - if(arg1 == nullptr) - { - DALI_LOG_ERROR("VideoView is nullptr!"); - return; - } - Dali::Animation *arg2 = (Dali::Animation*)jarg2; - if(arg2 == nullptr) - { - DALI_LOG_ERROR("Animation is nullptr!"); - return; - } - - { - try{ - - Toolkit::DevelVideoView::PlayAnimation(*arg1, *arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() { - void * jresult ; - Dali::Toolkit::GaussianBlurView *result = 0 ; - - { - try { - result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::GaussianBlurView *arg1 = 0 ; - Dali::Toolkit::GaussianBlurView *result = 0 ; - - arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; - Dali::Toolkit::GaussianBlurView *arg2 = 0 ; - Dali::Toolkit::GaussianBlurView *result = 0 ; - - arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; - arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) { - Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; - - arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::GaussianBlurView 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::GaussianBlurView::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() { - void * jresult ; - Dali::Toolkit::GaussianBlurView result; - - { - try { - result = Dali::Toolkit::GaussianBlurView::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, bool jarg6) { - void * jresult ; - unsigned int arg1 ; - float arg2 ; - Dali::Pixel::Format arg3 ; - float arg4 ; - float arg5 ; - bool arg6 ; - Dali::Toolkit::GaussianBlurView result; - - arg1 = (unsigned int)jarg1; - arg2 = (float)jarg2; - arg3 = (Dali::Pixel::Format)jarg3; - arg4 = (float)jarg4; - arg5 = (float)jarg5; - arg6 = jarg6 ? true : false; - { - try { - result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) { - void * jresult ; - unsigned int arg1 ; - float arg2 ; - Dali::Pixel::Format arg3 ; - float arg4 ; - float arg5 ; - Dali::Toolkit::GaussianBlurView result; - - arg1 = (unsigned int)jarg1; - arg2 = (float)jarg2; - arg3 = (Dali::Pixel::Format)jarg3; - arg4 = (float)jarg4; - arg5 = (float)jarg5; - { - try { - result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) { - Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->Add(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) { - Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->Remove(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) { - Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; - - arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; - { - try { - (arg1)->Activate(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) { - Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; - - arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; - { - try { - (arg1)->ActivateOnce(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) { - Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; - - arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; - { - try { - (arg1)->Deactivate(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) { - Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; - Dali::Texture arg2 ; - Dali::FrameBuffer arg3 ; - Dali::Texture *argp2 ; - Dali::FrameBuffer *argp3 ; - - arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; - argp2 = (Dali::Texture *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::FrameBuffer *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0); - return ; - } - arg3 = *argp3; - { - try { - (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) { - int jresult ; - Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; - Dali::Property::Index result; - - arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; - { - try { - result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) { - void * jresult ; - Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; - Dali::FrameBuffer result; - - arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; - { - try { - result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) { - Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; - Dali::Vector4 *arg2 = 0 ; - - arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return ; - } - { - try { - (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) { - void * jresult ; - Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; - Dali::Vector4 result; - - arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; - { - try { - result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ; - Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ; - - arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1; - { - try { - result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) { - Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ; - - arg1 = (Dali::Toolkit::PageFactory *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::PageFactory *)jarg1; - { - try { - result = (unsigned int)(arg1)->GetNumberOfPages(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) { - void * jresult ; - Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ; - unsigned int arg2 ; - Dali::Texture result; - - arg1 = (Dali::Toolkit::PageFactory *)jarg1; - arg2 = (unsigned int)jarg2; - { - try { - result = (arg1)->NewPage(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Texture((const Dali::Texture &)result); - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() { - void * jresult ; - Dali::Toolkit::PageTurnView::Property *result = 0 ; - - { - try { - result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) { - Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ; - - arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() { - void * jresult ; - Dali::Toolkit::PageTurnView *result = 0 ; - - { - try { - result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::PageTurnView *arg1 = 0 ; - Dali::Toolkit::PageTurnView *result = 0 ; - - arg1 = (Dali::Toolkit::PageTurnView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ; - Dali::Toolkit::PageTurnView *arg2 = 0 ; - Dali::Toolkit::PageTurnView *result = 0 ; - - arg1 = (Dali::Toolkit::PageTurnView *)jarg1; - arg2 = (Dali::Toolkit::PageTurnView *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) { - Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ; - - arg1 = (Dali::Toolkit::PageTurnView *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::PageTurnView 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::PageTurnView::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ; - Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ; - - arg1 = (Dali::Toolkit::PageTurnView *)jarg1; - { - try { - result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ; - Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ; - - arg1 = (Dali::Toolkit::PageTurnView *)jarg1; - { - try { - result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ; - Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ; - - arg1 = (Dali::Toolkit::PageTurnView *)jarg1; - { - try { - result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ; - Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ; - - arg1 = (Dali::Toolkit::PageTurnView *)jarg1; - { - try { - result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() { - void * jresult ; - Dali::Toolkit::PageTurnLandscapeView *result = 0 ; - - { - try { - result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ; - Dali::Toolkit::PageTurnLandscapeView *result = 0 ; - - arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ; - Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ; - Dali::Toolkit::PageTurnLandscapeView *result = 0 ; - - arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1; - arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) { - Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ; - - arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::PageFactory *arg1 = 0 ; - Dali::Vector2 *arg2 = 0 ; - Dali::Toolkit::PageTurnLandscapeView result; - - arg1 = (Dali::Toolkit::PageFactory *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0); - return 0; - } - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::PageTurnLandscapeView 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::PageTurnLandscapeView::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() { - void * jresult ; - Dali::Toolkit::PageTurnPortraitView *result = 0 ; - - { - try { - result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ; - Dali::Toolkit::PageTurnPortraitView *result = 0 ; - - arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ; - Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ; - Dali::Toolkit::PageTurnPortraitView *result = 0 ; - - arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1; - arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) { - Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ; - - arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::PageFactory *arg1 = 0 ; - Dali::Vector2 *arg2 = 0 ; - Dali::Toolkit::PageTurnPortraitView result; - - arg1 = (Dali::Toolkit::PageFactory *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0); - return 0; - } - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try { - result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::PageTurnPortraitView 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::PageTurnPortraitView::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() { - void * jresult ; - Dali::Toolkit::Visual::Base *result = 0 ; - - { - try { - result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) { - Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ; - - arg1 = (Dali::Toolkit::Visual::Base *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::Visual::Base *arg1 = 0 ; - Dali::Toolkit::Visual::Base *result = 0 ; - - arg1 = (Dali::Toolkit::Visual::Base *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ; - Dali::Toolkit::Visual::Base *arg2 = 0 ; - Dali::Toolkit::Visual::Base *result = 0 ; - - arg1 = (Dali::Toolkit::Visual::Base *)jarg1; - arg2 = (Dali::Toolkit::Visual::Base *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) { - Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Visual::Base *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - (arg1)->SetName((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - - - //argout typemap for const std::string& - -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) { - char * jresult ; - Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ; - std::string *result = 0 ; - - arg1 = (Dali::Toolkit::Visual::Base *)jarg1; - { - try { - result = (std::string *) &(arg1)->GetName(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) { - Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ; - Dali::Property::Map *arg2 = 0 ; - Dali::Size arg3 ; - Dali::Size *argp3 ; - - arg1 = (Dali::Toolkit::Visual::Base *)jarg1; - arg2 = (Dali::Property::Map *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); - return ; - } - argp3 = (Dali::Size *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0); - return ; - } - arg3 = *argp3; - { - try { - (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -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)(arg1)->GetHeightForWidth(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(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)(arg1)->GetWidthForHeight(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(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); - return ; - } - { - try { - (arg1)->GetNaturalSize(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) { - Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::Visual::Base *)jarg1; - arg2 = (int)jarg2; - { - try { - (arg1)->SetDepthIndex(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) { - int jresult ; - Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ; - int result; - - arg1 = (Dali::Toolkit::Visual::Base *)jarg1; - { - try { - result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) { - Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ; - Dali::Property::Map *arg2 = 0 ; - - arg1 = (Dali::Toolkit::Visual::Base *)jarg1; - arg2 = (Dali::Property::Map *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0); - return ; - } - { - try { - ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() { - void * jresult ; - Dali::Toolkit::VisualFactory result; - - { - try { - result = Dali::Toolkit::VisualFactory::Get(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() { - void * jresult ; - Dali::Toolkit::VisualFactory *result = 0 ; - - { - try { - result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) { - Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ; - - arg1 = (Dali::Toolkit::VisualFactory *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::VisualFactory *arg1 = 0 ; - Dali::Toolkit::VisualFactory *result = 0 ; - - arg1 = (Dali::Toolkit::VisualFactory *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ; - Dali::Toolkit::VisualFactory *arg2 = 0 ; - Dali::Toolkit::VisualFactory *result = 0 ; - - arg1 = (Dali::Toolkit::VisualFactory *)jarg1; - arg2 = (Dali::Toolkit::VisualFactory *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ; - Dali::Property::Map *arg2 = 0 ; - Dali::Toolkit::Visual::Base result; - - arg1 = (Dali::Toolkit::VisualFactory *)jarg1; - arg2 = (Dali::Property::Map *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); - return 0; - } - { - try { - result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) { - void * jresult ; - Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ; - std::string *arg2 = 0 ; - Dali::ImageDimensions arg3 ; - Dali::ImageDimensions *argp3 ; - Dali::Toolkit::Visual::Base result; - - arg1 = (Dali::Toolkit::VisualFactory *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - argp3 = (Dali::ImageDimensions *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg3 = *argp3; - { - try { - result = (arg1)->CreateVisual((std::string const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() { - void * jresult ; - Dali::Toolkit::AsyncImageLoader *result = 0 ; - - { - try { - result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) { - Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ; - - arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::AsyncImageLoader *arg1 = 0 ; - Dali::Toolkit::AsyncImageLoader *result = 0 ; - - arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ; - Dali::Toolkit::AsyncImageLoader *arg2 = 0 ; - Dali::Toolkit::AsyncImageLoader *result = 0 ; - - arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1; - arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() { - void * jresult ; - Dali::Toolkit::AsyncImageLoader result; - - { - try { - result = Dali::Toolkit::AsyncImageLoader::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::AsyncImageLoader 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::AsyncImageLoader::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result); - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) { - unsigned int jresult ; - Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ; - std::string *arg2 = 0 ; - uint32_t result; - - arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - result = (arg1)->Load((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) { - unsigned int jresult ; - Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ; - std::string *arg2 = 0 ; - Dali::ImageDimensions arg3 ; - Dali::ImageDimensions *argp3 ; - uint32_t result; - - arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - argp3 = (Dali::ImageDimensions *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg3 = *argp3; - { - try { - result = (arg1)->Load((std::string const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, bool jarg6) { - unsigned int jresult ; - Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ; - std::string *arg2 = 0 ; - Dali::ImageDimensions arg3 ; - Dali::FittingMode::Type arg4 ; - Dali::SamplingMode::Type arg5 ; - bool arg6 ; - Dali::ImageDimensions *argp3 ; - uint32_t result; - - arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - argp3 = (Dali::ImageDimensions *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg3 = *argp3; - arg4 = (Dali::FittingMode::Type)jarg4; - arg5 = (Dali::SamplingMode::Type)jarg5; - arg6 = jarg6 ? true : false; - { - try { - result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) { - bool jresult ; - Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ; - uint32_t arg2 ; - bool result; - - arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1; - arg2 = (uint32_t)jarg2; - { - try { - result = (bool)(arg1)->Cancel(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) { - Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ; - - arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1; - { - try { - (arg1)->CancelAll(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ; - Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1; - { - try { - result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::PixelData result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - { - try { - result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PixelData((const Dali::PixelData &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::ImageDimensions arg2 ; - Dali::ImageDimensions *argp2 ; - Dali::PixelData result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - argp2 = (Dali::ImageDimensions *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PixelData((const Dali::PixelData &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::ImageDimensions arg2 ; - Dali::FittingMode::Type arg3 ; - Dali::SamplingMode::Type arg4 ; - bool arg5 ; - Dali::ImageDimensions *argp2 ; - Dali::PixelData result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - argp2 = (Dali::ImageDimensions *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg2 = *argp2; - arg3 = (Dali::FittingMode::Type)jarg3; - arg4 = (Dali::SamplingMode::Type)jarg4; - arg5 = jarg5 ? true : false; - { - try { - result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PixelData((const Dali::PixelData &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) { - Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ; - - arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * customAlgorithmInterface, void * currentFocusedActor, void * proposedActorToFocus, int direction, char * deviceName) { - void * jresult ; - Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ; - Dali::Actor arg2 ; - Dali::Actor arg3 ; - Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ; - std::string *arg5 = 0 ; - Dali::Actor *argp2 ; - Dali::Actor *argp3 ; - Dali::Actor result; - - arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)customAlgorithmInterface; - argp2 = (Dali::Actor *)currentFocusedActor; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg2 = *argp2; - argp3 = (Dali::Actor *)proposedActorToFocus; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg3 = *argp3; - arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)direction; - - std::string arg5_str(deviceName); - arg5 = &arg5_str; - - { - try { - result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4,(std::string const &)*arg5); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() { - void * jresult ; - Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ; - - { - try { - result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) { - Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg; - SwigDirector_FrameCallbackInterface *director = dynamic_cast(obj); - if (director) { - director->swig_connect_director(callback0); - } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() { - void * jresult ; - Dali::FrameCallbackInterface *result = 0 ; - - { - try { - result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id, void* position) { - Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; - Dali::Vector3* vector3 = (Dali::Vector3 *)position; - return proxy->GetPosition(id, *vector3); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) { - Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; - Dali::Vector3* vector3 = (Dali::Vector3 *)position; - return proxy->SetPosition(id, *vector3); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) { - Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; - Dali::Vector3* vector3 = (Dali::Vector3 *)position; - return proxy->BakePosition(id, *vector3); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) { - Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; - Dali::Vector3* vector3 = (Dali::Vector3 *)size; - return proxy->GetSize(id, *vector3); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) { - Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; - Dali::Vector3* vector3 = (Dali::Vector3 *)size; - return proxy->SetSize(id, *vector3); -} -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) { - Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; - Dali::Vector3* vector3 = (Dali::Vector3 *)size; - return proxy->BakeSize(id, *vector3); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) { - Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; - Dali::Vector3* vector3_pos = (Dali::Vector3 *)position; - Dali::Vector3* vector3_size = (Dali::Vector3 *)size; - return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) { - Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; - Dali::Vector3* vector3 = (Dali::Vector3 *)scale; - return proxy->GetScale(id,* vector3); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) { - Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; - Dali::Vector3* vector3 = (Dali::Vector3 *)scale; - return proxy->SetScale(id, *vector3); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) { - Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; - Dali::Vector3* vector3 = (Dali::Vector3 *)scale; - return proxy->BakeScale(id, *vector3); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) { - Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; - Dali::Vector4* vector4 = (Dali::Vector4 *)color; - return proxy->GetColor(id, *vector4); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) { - Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; - Dali::Vector4* vector4 = (Dali::Vector4 *)color; - return proxy->SetColor(id, *vector4); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) { - Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy; - Dali::Vector4* vector4 = (Dali::Vector4 *)color; - return proxy->BakeColor(id, *vector4); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) { - Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2; - SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast(obj); - - Dali::Stage *arg1 = (Dali::Stage *) 0; - Dali::Actor *arg3 = 0; - - arg1 = (Dali::Stage *)jarg1; - arg3 = (Dali::Actor *)jarg3; - - DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 ); - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) { - - Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2; - SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast(obj); - - Dali::Stage *arg1 = (Dali::Stage *) 0; - - arg1 = (Dali::Stage *)jarg1; - - DevelStage::RemoveFrameCallback( *arg1, *arg2 ); - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) { - Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg; - SwigDirector_CustomAlgorithmInterface *director = dynamic_cast(obj); - if (director) { - director->swig_connect_director(callback0); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) { - KeyboardFocusManager arg1 ; - Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ; - KeyboardFocusManager *argp1 ; - - argp1 = (KeyboardFocusManager *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0); - return ; - } - arg1 = *argp1; - arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2; - //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value. - { - try { - Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_EnableDefaultAlgorithm(void * jarg1, bool jarg2) { - KeyboardFocusManager arg1 ; - bool arg2 ; - KeyboardFocusManager *argp1 ; - - argp1 = (KeyboardFocusManager *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0); - return ; - } - arg1 = *argp1; - arg2 = jarg2; - { - try { - Dali::Toolkit::DevelKeyboardFocusManager::EnableDefaultAlgorithm(arg1, arg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_IsDefaultAlgorithmEnabled(void * jarg1) { - bool jresult ; - KeyboardFocusManager arg1 ; - KeyboardFocusManager *argp1 ; - bool result; - - argp1 = (KeyboardFocusManager *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0); - return false; - } - arg1 = *argp1; - { - try { - result = Dali::Toolkit::DevelKeyboardFocusManager::IsDefaultAlgorithmEnabled(arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_SetFocusFinderRootActor(void * manager, void * actor) { - if (!manager) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0); - return ; - } - if (!actor) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); - return ; - } - { - try { - Dali::Toolkit::DevelKeyboardFocusManager::SetFocusFinderRootActor(*(KeyboardFocusManager *)manager, *(Dali::Actor *)actor); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardFocusManager_ResetFocusFinderRootActor(void * manager) { - if (!manager) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0); - return ; - } - { - try { - Dali::Toolkit::DevelKeyboardFocusManager::ResetFocusFinderRootActor(*(KeyboardFocusManager *)manager); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) { - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - - arg1 = (std::vector< unsigned int > *)jarg1; - { - try { - (arg1)->clear(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) { - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - unsigned int *arg2 = 0 ; - unsigned int temp2 ; - - arg1 = (std::vector< unsigned int > *)jarg1; - temp2 = (unsigned int)jarg2; - arg2 = &temp2; - { - try { - (arg1)->push_back((unsigned int const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) { - unsigned long jresult ; - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - std::vector< unsigned int >::size_type result; - - arg1 = (std::vector< unsigned int > *)jarg1; - { - try { - result = ((std::vector< unsigned int > const *)arg1)->size(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) { - unsigned long jresult ; - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - std::vector< unsigned int >::size_type result; - - arg1 = (std::vector< unsigned int > *)jarg1; - { - try { - result = ((std::vector< unsigned int > const *)arg1)->capacity(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) { - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - std::vector< unsigned int >::size_type arg2 ; - - arg1 = (std::vector< unsigned int > *)jarg1; - arg2 = (std::vector< unsigned int >::size_type)jarg2; - { - try { - (arg1)->reserve(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() { - void * jresult ; - std::vector< unsigned int > *result = 0 ; - - { - try { - result = (std::vector< unsigned int > *)new std::vector< unsigned int >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) { - void * jresult ; - std::vector< unsigned int > *arg1 = 0 ; - std::vector< unsigned int > *result = 0 ; - - arg1 = (std::vector< unsigned int > *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0); - return 0; - } - { - try { - result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) { - void * jresult ; - int arg1 ; - std::vector< unsigned int > *result = 0 ; - - arg1 = (int)jarg1; - { - try { - try { - result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) { - unsigned int jresult ; - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - int arg2 ; - unsigned int result; - - arg1 = (std::vector< unsigned int > *)jarg1; - arg2 = (int)jarg2; - { - try { - try { - result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) { - unsigned int jresult ; - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - int arg2 ; - unsigned int *result = 0 ; - - arg1 = (std::vector< unsigned int > *)jarg1; - arg2 = (int)jarg2; - { - try { - try { - result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = *result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) { - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - int arg2 ; - unsigned int *arg3 = 0 ; - unsigned int temp3 ; - - arg1 = (std::vector< unsigned int > *)jarg1; - arg2 = (int)jarg2; - temp3 = (unsigned int)jarg3; - arg3 = &temp3; - { - try { - try { - std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) { - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - std::vector< unsigned int > *arg2 = 0 ; - - arg1 = (std::vector< unsigned int > *)jarg1; - arg2 = (std::vector< unsigned int > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0); - return ; - } - { - try { - std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) { - void * jresult ; - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - int arg2 ; - int arg3 ; - std::vector< unsigned int > *result = 0 ; - - arg1 = (std::vector< unsigned int > *)jarg1; - arg2 = (int)jarg2; - arg3 = (int)jarg3; - { - try { - try { - result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - catch(std::invalid_argument &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) { - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - int arg2 ; - unsigned int *arg3 = 0 ; - unsigned int temp3 ; - - arg1 = (std::vector< unsigned int > *)jarg1; - arg2 = (int)jarg2; - temp3 = (unsigned int)jarg3; - arg3 = &temp3; - { - try { - try { - std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) { - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - int arg2 ; - std::vector< unsigned int > *arg3 = 0 ; - - arg1 = (std::vector< unsigned int > *)jarg1; - arg2 = (int)jarg2; - arg3 = (std::vector< unsigned int > *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0); - return ; - } - { - try { - try { - std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) { - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - int arg2 ; - - arg1 = (std::vector< unsigned int > *)jarg1; - arg2 = (int)jarg2; - { - try { - try { - std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) { - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - int arg2 ; - int arg3 ; - - arg1 = (std::vector< unsigned int > *)jarg1; - arg2 = (int)jarg2; - arg3 = (int)jarg3; - { - try { - try { - std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - catch(std::invalid_argument &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) { - void * jresult ; - unsigned int *arg1 = 0 ; - int arg2 ; - unsigned int temp1 ; - std::vector< unsigned int > *result = 0 ; - - temp1 = (unsigned int)jarg1; - arg1 = &temp1; - arg2 = (int)jarg2; - { - try { - try { - result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) { - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - - arg1 = (std::vector< unsigned int > *)jarg1; - { - try { - std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) { - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - int arg2 ; - int arg3 ; - - arg1 = (std::vector< unsigned int > *)jarg1; - arg2 = (int)jarg2; - arg3 = (int)jarg3; - { - try { - try { - std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - catch(std::invalid_argument &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) { - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - int arg2 ; - std::vector< unsigned int > *arg3 = 0 ; - - arg1 = (std::vector< unsigned int > *)jarg1; - arg2 = (int)jarg2; - arg3 = (std::vector< unsigned int > *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0); - return ; - } - { - try { - try { - std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) { - bool jresult ; - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - unsigned int *arg2 = 0 ; - unsigned int temp2 ; - bool result; - - arg1 = (std::vector< unsigned int > *)jarg1; - temp2 = (unsigned int)jarg2; - arg2 = &temp2; - { - try { - result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) { - int jresult ; - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - unsigned int *arg2 = 0 ; - unsigned int temp2 ; - int result; - - arg1 = (std::vector< unsigned int > *)jarg1; - temp2 = (unsigned int)jarg2; - arg2 = &temp2; - { - try { - result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) { - int jresult ; - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - unsigned int *arg2 = 0 ; - unsigned int temp2 ; - int result; - - arg1 = (std::vector< unsigned int > *)jarg1; - temp2 = (unsigned int)jarg2; - arg2 = &temp2; - { - try { - result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) { - bool jresult ; - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - unsigned int *arg2 = 0 ; - unsigned int temp2 ; - bool result; - - arg1 = (std::vector< unsigned int > *)jarg1; - temp2 = (unsigned int)jarg2; - arg2 = &temp2; - { - try { - result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) { - std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ; - - arg1 = (std::vector< unsigned int > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() { - void * jresult ; - std::pair< unsigned int,Dali::Actor > *result = 0 ; - - { - try { - result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) { - void * jresult ; - unsigned int arg1 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - std::pair< unsigned int,Dali::Actor > *result = 0 ; - - arg1 = (unsigned int)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) { - void * jresult ; - std::pair< unsigned int,Dali::Actor > *arg1 = 0 ; - std::pair< unsigned int,Dali::Actor > *result = 0 ; - - arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0); - return 0; - } - { - try { - result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) { - std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ; - unsigned int arg2 ; - - arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1; - arg2 = (unsigned int)jarg2; - if (arg1) (arg1)->first = arg2; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) { - unsigned int jresult ; - std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ; - unsigned int result; - - arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1; - result = (unsigned int) ((arg1)->first); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) { - std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ; - Dali::Actor *arg2 = (Dali::Actor *) 0 ; - - arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1; - arg2 = (Dali::Actor *)jarg2; - if (arg1) (arg1)->second = *arg2; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) { - void * jresult ; - std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ; - Dali::Actor *result = 0 ; - - arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1; - result = (Dali::Actor *)& ((arg1)->second); - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) { - std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ; - - arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) { - std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; - - arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; - { - try { - (arg1)->clear(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) { - std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; - std::pair< unsigned int,Dali::Actor > *arg2 = 0 ; - - arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; - arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0); - return ; - } - { - try { - (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) { - unsigned long jresult ; - std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; - std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result; - - arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; - { - try { - result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) { - unsigned long jresult ; - std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; - std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result; - - arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; - { - try { - result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) { - std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; - std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ; - - arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; - arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2; - { - try { - (arg1)->reserve(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() { - void * jresult ; - std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ; - - { - try { - result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) { - void * jresult ; - std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ; - std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ; - - arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0); - return 0; - } - { - try { - result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >((std::vector< std::pair< unsigned int,Dali::Actor > > const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) { - void * jresult ; - int arg1 ; - std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ; - - arg1 = (int)jarg1; - { - try { - try { - result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(arg1); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) { - void * jresult ; - std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; - int arg2 ; - std::pair< unsigned int,Dali::Actor > result; - - arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; - arg2 = (int)jarg2; - { - try { - try { - result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) { - void * jresult ; - std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; - int arg2 ; - std::pair< unsigned int,Dali::Actor > *result = 0 ; - - arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; - arg2 = (int)jarg2; - { - try { - try { - result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) { - std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; - int arg2 ; - std::pair< unsigned int,Dali::Actor > *arg3 = 0 ; - - arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; - arg2 = (int)jarg2; - arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0); - return ; - } - { - try { - try { - std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(arg1,arg2,(std::pair< unsigned int,Dali::Actor > const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) { - std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; - std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ; - - arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; - arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0); - return ; - } - { - try { - std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(arg1,(std::vector< std::pair< unsigned int,Dali::Actor > > const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) { - void * jresult ; - std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; - int arg2 ; - int arg3 ; - std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ; - - arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; - arg2 = (int)jarg2; - arg3 = (int)jarg3; - { - try { - try { - result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - catch(std::invalid_argument &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) { - std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; - int arg2 ; - std::pair< unsigned int,Dali::Actor > *arg3 = 0 ; - - arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; - arg2 = (int)jarg2; - arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0); - return ; - } - { - try { - try { - std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(arg1,arg2,(std::pair< unsigned int,Dali::Actor > const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) { - std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; - int arg2 ; - std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ; - - arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; - arg2 = (int)jarg2; - arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0); - return ; - } - { - try { - try { - std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::pair< unsigned int,Dali::Actor > > const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) { - std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; - int arg2 ; - - arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; - arg2 = (int)jarg2; - { - try { - try { - std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) { - std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; - int arg2 ; - int arg3 ; - - arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; - arg2 = (int)jarg2; - arg3 = (int)jarg3; - { - try { - try { - std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - catch(std::invalid_argument &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) { - void * jresult ; - std::pair< unsigned int,Dali::Actor > *arg1 = 0 ; - int arg2 ; - std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ; - - arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0); - return 0; - } - arg2 = (int)jarg2; - { - try { - try { - result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat((std::pair< unsigned int,Dali::Actor > const &)*arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) { - std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; - - arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; - { - try { - std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) { - std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; - int arg2 ; - int arg3 ; - - arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; - arg2 = (int)jarg2; - arg3 = (int)jarg3; - { - try { - try { - std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - catch(std::invalid_argument &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) { - std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; - int arg2 ; - std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ; - - arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; - arg2 = (int)jarg2; - arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0); - return ; - } - { - try { - try { - std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(arg1,arg2,(std::vector< std::pair< unsigned int,Dali::Actor > > const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) { - std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ; - - arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) { - std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; - - arg1 = (std::vector< Dali::Actor > *)jarg1; - { - try { - (arg1)->clear(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) { - std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; - Dali::Actor *arg2 = 0 ; - - arg1 = (std::vector< Dali::Actor > *)jarg1; - arg2 = (Dali::Actor *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); - return ; - } - { - try { - (arg1)->push_back((Dali::Actor const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) { - unsigned long jresult ; - std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; - std::vector< Dali::Actor >::size_type result; - - arg1 = (std::vector< Dali::Actor > *)jarg1; - { - try { - result = ((std::vector< Dali::Actor > const *)arg1)->size(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) { - unsigned long jresult ; - std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; - std::vector< Dali::Actor >::size_type result; - - arg1 = (std::vector< Dali::Actor > *)jarg1; - { - try { - result = ((std::vector< Dali::Actor > const *)arg1)->capacity(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) { - std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; - std::vector< Dali::Actor >::size_type arg2 ; - - arg1 = (std::vector< Dali::Actor > *)jarg1; - arg2 = (std::vector< Dali::Actor >::size_type)jarg2; - { - try { - (arg1)->reserve(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() { - void * jresult ; - std::vector< Dali::Actor > *result = 0 ; - - { - try { - result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) { - void * jresult ; - std::vector< Dali::Actor > *arg1 = 0 ; - std::vector< Dali::Actor > *result = 0 ; - - arg1 = (std::vector< Dali::Actor > *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0); - return 0; - } - { - try { - result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) { - void * jresult ; - int arg1 ; - std::vector< Dali::Actor > *result = 0 ; - - arg1 = (int)jarg1; - { - try { - try { - result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) { - void * jresult ; - std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; - int arg2 ; - Dali::Actor result; - - arg1 = (std::vector< Dali::Actor > *)jarg1; - arg2 = (int)jarg2; - { - try { - try { - result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) { - void * jresult ; - std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; - int arg2 ; - Dali::Actor *result = 0 ; - - arg1 = (std::vector< Dali::Actor > *)jarg1; - arg2 = (int)jarg2; - { - try { - try { - result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) { - std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; - int arg2 ; - Dali::Actor *arg3 = 0 ; - - arg1 = (std::vector< Dali::Actor > *)jarg1; - arg2 = (int)jarg2; - arg3 = (Dali::Actor *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); - return ; - } - { - try { - try { - std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) { - std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; - std::vector< Dali::Actor > *arg2 = 0 ; - - arg1 = (std::vector< Dali::Actor > *)jarg1; - arg2 = (std::vector< Dali::Actor > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0); - return ; - } - { - try { - std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) { - void * jresult ; - std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; - int arg2 ; - int arg3 ; - std::vector< Dali::Actor > *result = 0 ; - - arg1 = (std::vector< Dali::Actor > *)jarg1; - arg2 = (int)jarg2; - arg3 = (int)jarg3; - { - try { - try { - result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - catch(std::invalid_argument &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) { - std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; - int arg2 ; - Dali::Actor *arg3 = 0 ; - - arg1 = (std::vector< Dali::Actor > *)jarg1; - arg2 = (int)jarg2; - arg3 = (Dali::Actor *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); - return ; - } - { - try { - try { - std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) { - std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; - int arg2 ; - std::vector< Dali::Actor > *arg3 = 0 ; - - arg1 = (std::vector< Dali::Actor > *)jarg1; - arg2 = (int)jarg2; - arg3 = (std::vector< Dali::Actor > *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0); - return ; - } - { - try { - try { - std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) { - std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; - int arg2 ; - - arg1 = (std::vector< Dali::Actor > *)jarg1; - arg2 = (int)jarg2; - { - try { - try { - std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) { - std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; - int arg2 ; - int arg3 ; - - arg1 = (std::vector< Dali::Actor > *)jarg1; - arg2 = (int)jarg2; - arg3 = (int)jarg3; - { - try { - try { - std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - catch(std::invalid_argument &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) { - void * jresult ; - Dali::Actor *arg1 = 0 ; - int arg2 ; - std::vector< Dali::Actor > *result = 0 ; - - arg1 = (Dali::Actor *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); - return 0; - } - arg2 = (int)jarg2; - { - try { - try { - result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return 0; - } - - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) { - std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; - - arg1 = (std::vector< Dali::Actor > *)jarg1; - { - try { - std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) { - std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; - int arg2 ; - int arg3 ; - - arg1 = (std::vector< Dali::Actor > *)jarg1; - arg2 = (int)jarg2; - arg3 = (int)jarg3; - { - try { - try { - std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - catch(std::invalid_argument &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), ""); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) { - std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; - int arg2 ; - std::vector< Dali::Actor > *arg3 = 0 ; - - arg1 = (std::vector< Dali::Actor > *)jarg1; - arg2 = (int)jarg2; - arg3 = (std::vector< Dali::Actor > *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0); - return ; - } - { - try { - try { - std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3); - } - catch(std::out_of_range &_e) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what()); - return ; - } - - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) { - std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ; - - arg1 = (std::vector< Dali::Actor > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1; - { - try { - result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ; - bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ; - - arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1; - arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2; - { - try { - Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ; - bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ; - - arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1; - arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2; - { - try { - Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) { - bool jresult ; - Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ; - Dali::Toolkit::AccessibilityManager *arg2 = 0 ; - bool result; - - arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1; - arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0); - return 0; - } - { - try { - result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() { - void * jresult ; - Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ; - - { - try { - result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) { - Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ; - - arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ; - void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1; - arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ; - void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1; - arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) { - Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ; - Dali::Actor arg2 ; - Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() { - void * jresult ; - Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) { - Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ; - void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1; - arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ; - void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1; - arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) { - Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ; - Dali::Actor arg2 ; - Dali::Actor arg3 ; - Dali::Actor *argp2 ; - Dali::Actor *argp3 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - argp3 = (Dali::Actor *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg3 = *argp3; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() { - void * jresult ; - Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) { - Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ; - void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1; - arg2 = (void (*)(Dali::Actor,bool))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ; - void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1; - arg2 = (void (*)(Dali::Actor,bool))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, bool jarg3) { - Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ; - Dali::Actor arg2 ; - bool arg3 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - arg3 = jarg3 ? true : false; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() { - void * jresult ; - Dali::Signal< void (Dali::Actor,bool) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) { - Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ; - void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ; - void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) { - Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ; - Dali::Toolkit::StyleManager arg2 ; - Dali::StyleChange::Type arg3 ; - Dali::Toolkit::StyleManager *argp2 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1; - argp2 = (Dali::Toolkit::StyleManager *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::StyleChange::Type)jarg3; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() { - void * jresult ; - Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) { - Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ; - void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ; - void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ; - Dali::Toolkit::GaussianBlurView arg2 ; - Dali::Toolkit::GaussianBlurView *argp2 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1; - argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0); - return ; - } - arg2 = *argp2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() { - void * jresult ; - Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) { - Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ; - void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ; - void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, bool jarg4) { - Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ; - Dali::Toolkit::PageTurnView arg2 ; - unsigned int arg3 ; - bool arg4 ; - Dali::Toolkit::PageTurnView *argp2 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1; - argp2 = (Dali::Toolkit::PageTurnView *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0); - return ; - } - arg2 = *argp2; - arg3 = (unsigned int)jarg3; - arg4 = jarg4 ? true : false; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() { - void * jresult ; - Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) { - Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ; - void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ; - void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ; - Dali::Toolkit::PageTurnView arg2 ; - Dali::Toolkit::PageTurnView *argp2 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1; - argp2 = (Dali::Toolkit::PageTurnView *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0); - return ; - } - arg2 = *argp2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() { - void * jresult ; - Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) { - Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ; - void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ; - void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ; - Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1; - arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0); - return ; - } - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() { - void * jresult ; - Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) { - Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ; - void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1; - arg2 = (void (*)(Dali::Vector2 const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ; - void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1; - arg2 = (void (*)(Dali::Vector2 const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ; - Dali::Vector2 *arg2 = 0 ; - - arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return ; - } - { - try { - Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() { - void * jresult ; - Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) { - Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ; - void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ; - void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ; - Dali::Toolkit::VideoView *arg2 = 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1; - arg2 = (Dali::Toolkit::VideoView *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0); - return ; - } - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() { - void * jresult ; - Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) { - Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() { - void * jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ; - - { - try { - result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ; - - arg1 = (Dali::Toolkit::Ruler *)jarg1; - { - try { - result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) { - void * jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0); - return 0; - } - { - try { - result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) { - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) { - void * jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - Dali::Toolkit::Ruler *result = 0 ; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - { - try { - result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) { - void * jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - Dali::Toolkit::Ruler *result = 0 ; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - { - try { - result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) { - void * jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - Dali::Toolkit::Ruler *result = 0 ; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - { - try { - result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0); - return 0; - } - { - try { - result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) { - void * jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - arg2 = (Dali::Toolkit::Ruler *)jarg2; - { - try { - result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) { - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - { - try { - (arg1)->Reset(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) { - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - arg2 = (Dali::Toolkit::Ruler *)jarg2; - { - try { - (arg1)->Reset(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) { - void * jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - Dali::Toolkit::Ruler *result = 0 ; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - { - try { - result = (Dali::Toolkit::Ruler *)(arg1)->Detach(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) { - float jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - float arg2 ; - float arg3 ; - float result; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - { - try { - result = (float)(*arg1)->Snap(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) { - float jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - float arg2 ; - float result; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - arg2 = (float)jarg2; - { - try { - result = (float)(*arg1)->Snap(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, bool jarg4) { - float jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - unsigned int arg2 ; - unsigned int *arg3 = 0 ; - bool arg4 ; - float result; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (unsigned int *)jarg3; - arg4 = jarg4 ? true : false; - { - try { - result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, bool jarg3) { - unsigned int jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - float arg2 ; - bool arg3 ; - unsigned int result; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - arg2 = (float)jarg2; - arg3 = jarg3 ? true : false; - { - try { - result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) { - unsigned int jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - unsigned int result; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - { - try { - result = (unsigned int)(*arg1)->GetTotalPages(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) { - int jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - Dali::Toolkit::Ruler::RulerType result; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - { - try { - result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) { - bool jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - bool result; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - { - try { - result = (bool)(*arg1)->IsEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) { - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - { - try { - (*arg1)->Enable(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) { - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - { - try { - (*arg1)->Disable(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) { - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ; - Dali::Toolkit::RulerDomain *argp2 ; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - argp2 = (Dali::Toolkit::RulerDomain *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0); - return ; - } - arg2 = *argp2; - { - try { - (*arg1)->SetDomain(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) { - void * jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - Dali::Toolkit::RulerDomain *result = 0 ; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - { - try { - result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) { - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - { - try { - (*arg1)->DisableDomain(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) { - float jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - float arg2 ; - float arg3 ; - float arg4 ; - float result; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - { - try { - result = (float)(*arg1)->Clamp(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) { - float jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - float arg2 ; - float arg3 ; - float result; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - { - try { - result = (float)(*arg1)->Clamp(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) { - float jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - float arg2 ; - float result; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - arg2 = (float)jarg2; - { - try { - result = (float)(*arg1)->Clamp(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) { - float jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - float arg2 ; - float arg3 ; - float arg4 ; - Dali::Toolkit::ClampState *arg5 = 0 ; - float result; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - arg5 = (Dali::Toolkit::ClampState *)jarg5; - if (!arg5) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0); - return 0; - } - { - try { - result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) { - float jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - float arg2 ; - float arg3 ; - float arg4 ; - float arg5 ; - float result; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - arg5 = (float)jarg5; - { - try { - result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) { - float jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - float arg2 ; - float arg3 ; - float arg4 ; - float result; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - { - try { - result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) { - float jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - float arg2 ; - float arg3 ; - float result; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - { - try { - result = (float)(*arg1)->SnapAndClamp(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) { - float jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - float arg2 ; - float result; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - arg2 = (float)jarg2; - { - try { - result = (float)(*arg1)->SnapAndClamp(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) { - float jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - float arg2 ; - float arg3 ; - float arg4 ; - float arg5 ; - Dali::Toolkit::ClampState *arg6 = 0 ; - float result; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - arg5 = (float)jarg5; - arg6 = (Dali::Toolkit::ClampState *)jarg6; - if (!arg6) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0); - return 0; - } - { - try { - result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) { - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - { - try { - (*arg1)->Reference(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) { - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - { - try { - (*arg1)->Unreference(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) { - int jresult ; - Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ; - int result; - - arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1; - { - try { - result = (int)(*arg1)->ReferenceCount(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) { - bool jresult ; - Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ; - void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::Control))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ; - void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::Control))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ; - Dali::Toolkit::Control arg2 ; - Dali::Toolkit::Control *argp2 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1; - argp2 = (Dali::Toolkit::Control *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0); - return ; - } - arg2 = *argp2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() { - void * jresult ; - Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) { - Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) { - Dali::RefObject *result = NULL; - - if (arg1) - { - result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr(); - } - return result; -} - -SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) { - return (Dali::RefObject *)jarg1; -} - -SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) { - return (Dali::SignalObserver *)jarg1; -} - -SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) { - return (Dali::ConnectionTrackerInterface *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) { - return (Dali::Handle *)jarg1; -} - -SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) { - return (Dali::Handle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) { - return (Dali::Handle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Key_SWIGUpcast(Dali::KeyEvent *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Gesture_SWIGUpcast(Dali::Gesture *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) { - return (Dali::Handle *)jarg1; -} - -SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) { - return (Dali::GestureDetector *)jarg1; -} - -SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) { - return (Dali::Gesture *)jarg1; -} - - -SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) { - return (Dali::RefObject *)jarg1; -} - -SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) { - return (Dali::Actor *)jarg1; -} - -SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) { - return (Dali::GestureDetector *)jarg1; -} - -SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) { - return (Dali::Gesture *)jarg1; -} - -SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) { - return (Dali::GestureDetector *)jarg1; -} - -SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) { - return (Dali::Gesture *)jarg1; -} - -SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) { - return (Dali::GestureDetector *)jarg1; -} - -SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) { - return (Dali::Gesture *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) { - return (Dali::Handle *)jarg1; -} - -SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) { - return (Dali::Handle *)jarg1; -} - -SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) { - return (Dali::Handle *)jarg1; -} - -SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) { - return (Dali::RefObject *)jarg1; -} - -SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) { - return (Dali::Actor *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) { - 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; -} - -SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *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; -} - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - -SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) { - return (Dali::RefObject *)jarg1; -} - -SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) { - return (Dali::Toolkit::Scrollable *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) { - return (Dali::Toolkit::ScrollViewEffect *)jarg1; -} - -SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) { - return (Dali::RefObject *)jarg1; -} - -SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) { - return (Dali::Toolkit::Ruler *)jarg1; -} - -SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) { - return (Dali::Toolkit::Ruler *)jarg1; -} - -SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) { - return (Dali::Toolkit::Scrollable *)jarg1; -} - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_CameraView_SWIGUpcast(Dali::Toolkit::CameraView *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - -SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) { - return (Dali::Toolkit::PageTurnView *)jarg1; -} - -SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) { - return (Dali::Toolkit::PageTurnView *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -/* - * Widget binding - */ -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) { - return (Dali::BaseObject *)jarg1; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() { - void * jresult ; - Dali::Widget result; - - { - try { - result = Dali::Widget::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Widget((const Dali::Widget &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Internal::Adaptor::Widget *arg1 = 0 ; - Dali::Widget result; - - arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; - - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0); - return 0; - } - { - try { - jresult = new Dali::Widget(arg1); - } CALL_CATCH_EXCEPTION(0); - } - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() { - void * jresult ; - Dali::Widget *result = 0 ; - - { - try { - result = (Dali::Widget *)new Dali::Widget(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Widget *arg1 = (Dali::Widget *) 0 ; - Dali::Widget *arg2 = 0 ; - Dali::Widget *result = 0 ; - - arg1 = (Dali::Widget *)jarg1; - arg2 = (Dali::Widget *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) { - Dali::Widget *arg1 = (Dali::Widget *) 0 ; - - arg1 = (Dali::Widget *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() { - void * jresult ; - SwigDirector_WidgetImpl* result; - { - try { - result = new SwigDirector_WidgetImpl(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) { - Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; - std::string *arg2 = 0 ; - Dali::Window arg3 ; - Dali::Window *argp3 ; - - arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - argp3 = (Dali::Window *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - arg3 = *argp3; - { - try { - (arg1)->OnCreate((std::string const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) { - Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; - std::string *arg2 = 0 ; - Dali::Window arg3 ; - Dali::Window *argp3 ; - - arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - argp3 = (Dali::Window *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - arg3 = *argp3; - { - try { - (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) { - Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; - std::string *arg2 = 0 ; - Dali::Widget::Termination arg3 ; - - arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Widget::Termination)jarg3; - { - try { - (arg1)->OnTerminate((std::string const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) { - Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; - std::string *arg2 = 0 ; - Dali::Widget::Termination arg3 ; - - arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Widget::Termination)jarg3; - { - try { - (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) { - Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; - - arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; - { - try { - (arg1)->OnPause(); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) { - Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; - - arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; - { - try { - (arg1)->Dali::Internal::Adaptor::Widget::OnPause(); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) { - Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; - - arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; - { - try { - (arg1)->OnResume(); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) { - Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; - - arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; - { - try { - (arg1)->Dali::Internal::Adaptor::Widget::OnResume(); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) { - Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; - Dali::Window arg2 ; - Dali::Window *argp2 ; - - arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; - argp2 = (Dali::Window *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->OnResize(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) { - Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; - Dali::Window arg2 ; - Dali::Window *argp2 ; - - arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; - argp2 = (Dali::Window *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) { - Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; - std::string *arg2 = 0 ; - int arg3 ; - - arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (int)jarg3; - { - try { - (arg1)->OnUpdate((std::string const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) { - Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; - std::string *arg2 = 0 ; - int arg3 ; - - arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (int)jarg3; - { - try { - (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) { - Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; - Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; - Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; - - arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; - arg2 = (Dali::SlotObserver *)jarg2; - arg3 = (Dali::CallbackBase *)jarg3; - { - try { - (arg1)->SignalConnected(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) { - Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; - Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; - Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; - - arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; - arg2 = (Dali::SlotObserver *)jarg2; - arg3 = (Dali::CallbackBase *)jarg3; - { - try { - (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) { - Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; - Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; - Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; - - arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; - arg2 = (Dali::SlotObserver *)jarg2; - arg3 = (Dali::CallbackBase *)jarg3; - { - try { - (arg1)->SignalDisconnected(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) { - Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; - Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ; - Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ; - - arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; - arg2 = (Dali::SlotObserver *)jarg2; - arg3 = (Dali::CallbackBase *)jarg3; - { - try { - (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) { - Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - (arg1)->SetContentInfo((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetUsingKeyEvent(void * jwidget, bool jflag) { - Dali::Internal::Adaptor::Widget *widget = (Dali::Internal::Adaptor::Widget *) 0 ; - bool flag; - - widget = (Dali::Internal::Adaptor::Widget *)jwidget; - flag = jflag ? true : false; - { - try { - (widget)->SetUsingKeyEvent(flag); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) { - Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ; - Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ; - - arg1 = (Dali::Internal::Adaptor::Widget *)jarg1; - arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2; - { - try { - (arg1)->SetImpl(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_director_connect(void *objarg, SwigDirector_WidgetImpl::SWIG_Callback0_t callback0, SwigDirector_WidgetImpl::SWIG_Callback1_t callback1, SwigDirector_WidgetImpl::SWIG_Callback2_t callback2, SwigDirector_WidgetImpl::SWIG_Callback3_t callback3, SwigDirector_WidgetImpl::SWIG_Callback4_t callback4, SwigDirector_WidgetImpl::SWIG_Callback5_t callback5, SwigDirector_WidgetImpl::SWIG_Callback6_t callback6, SwigDirector_WidgetImpl::SWIG_Callback7_t callback7) { - SwigDirector_WidgetImpl *director = static_cast(objarg); - if (director) { - director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7); - } -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) { - void * jresult ; - Dali::Widget *arg1 = 0 ; - SwigDirector_WidgetImpl *result = 0 ; - - arg1 = (Dali::Widget *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0); - return 0; - } - { - try { - result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void*) result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) { - void * jresult ; - int *arg1 = (int *) 0 ; - char ***arg2 ; - std::string *arg3 = 0 ; - Dali::WidgetApplication result; - { - int index = 0; - int length = 0; - char *retPtr; - char *nextPtr; - argWidgetC = jarg1; - argWidgetV = new char*[jarg1 + 1]; - - retPtr = strtok_r( jarg2, " ", &nextPtr); - if( retPtr ) - { - length = strlen(retPtr); - } - argWidgetV[index] = new char[length + 1]; - if( retPtr ) - { - strncpy(argWidgetV[index], retPtr, length); - } - argWidgetV[index][length] = '\0'; - index++; - - while (index < jarg1) - { - length = 0; - retPtr = strtok_r(NULL, " ", &nextPtr); - if( retPtr ) - { - length = strlen(retPtr); - } - argWidgetV[index] = new char[length + 1]; - if( retPtr ) - { - strncpy(argWidgetV[index], retPtr, length); - } - argWidgetV[index][length] = '\0'; - index++; - } - - argWidgetV[jarg1] = NULL; - argWidgetC = jarg1; - - arg1 = &argWidgetC; - arg2 = &argWidgetV; - } - - if (!jarg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg3_str(jarg3); - arg3 = &arg3_str; - { - try { - result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() { - void * jresult ; - Dali::WidgetApplication *result = 0 ; - - { - try { - result = (Dali::WidgetApplication *)new Dali::WidgetApplication(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) { - void * jresult ; - Dali::WidgetApplication *arg1 = 0 ; - Dali::WidgetApplication *result = 0 ; - - arg1 = (Dali::WidgetApplication *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0); - return 0; - } - { - try { - result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ; - Dali::WidgetApplication *arg2 = 0 ; - Dali::WidgetApplication *result = 0 ; - - arg1 = (Dali::WidgetApplication *)jarg1; - arg2 = (Dali::WidgetApplication *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0); - return 0; - } - { - try { - result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) { - Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ; - - arg1 = (Dali::WidgetApplication *)jarg1; - { - try { - delete arg1; - if( argWidgetV ) - { - // free string data - for( int i=0; i < argWidgetC+1; i++) - { - delete [] argWidgetV[i]; - } - delete [] argWidgetV; - } - } CALL_CATCH_EXCEPTION(); - } -} - - -typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&); -CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL; - -static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName ) -{ - Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() ); - return *widget; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) { - Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::WidgetApplication *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(*jarg2); - arg2 = &arg2_str; - - if(!_CSharpCreateWidgetFunction) - { - _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3; - } - - { - try { - (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction); - } CALL_CATCH_EXCEPTION(); - } - *jarg2 = SWIG_csharp_string_callback(arg2->c_str()); -} - - -//for PixelBuffer and ImageLoading - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) { - void * jresult ; - unsigned int arg1 ; - unsigned int arg2 ; - Dali::Pixel::Format arg3 ; - Dali::Devel::PixelBuffer result; - - arg1 = (unsigned int)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (Dali::Pixel::Format)jarg3; - { - try { - result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() { - void * jresult ; - Dali::Devel::PixelBuffer *result = 0 ; - - { - try { - result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) { - Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; - - arg1 = (Dali::Devel::PixelBuffer *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Devel::PixelBuffer *arg1 = 0 ; - Dali::Devel::PixelBuffer *result = 0 ; - - arg1 = (Dali::Devel::PixelBuffer *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; - Dali::Devel::PixelBuffer *arg2 = 0 ; - Dali::Devel::PixelBuffer *result = 0 ; - - arg1 = (Dali::Devel::PixelBuffer *)jarg1; - arg2 = (Dali::Devel::PixelBuffer *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) { - void * jresult ; - Dali::Devel::PixelBuffer *arg1 = 0 ; - Dali::PixelData result; - - arg1 = (Dali::Devel::PixelBuffer *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0); - return 0; - } - { - try { - result = Dali::Devel::PixelBuffer::Convert(*arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::PixelData((const Dali::PixelData &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) { - void * jresult ; - Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; - Dali::PixelData result; - - arg1 = (Dali::Devel::PixelBuffer *)jarg1; - { - try { - result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::PixelData((const Dali::PixelData &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) { - void * jresult ; - Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; - unsigned char *result = 0 ; - - arg1 = (Dali::Devel::PixelBuffer *)jarg1; - { - try { - result = (unsigned char *)(arg1)->GetBuffer(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) { - unsigned int jresult ; - Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; - unsigned int result; - - arg1 = (Dali::Devel::PixelBuffer *)jarg1; - { - try { - result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) { - unsigned int jresult ; - Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; - unsigned int result; - - arg1 = (Dali::Devel::PixelBuffer *)jarg1; - { - try { - result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) { - int jresult ; - Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; - Dali::Pixel::Format result; - - arg1 = (Dali::Devel::PixelBuffer *)jarg1; - { - try { - result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, bool jarg4) { - Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; - Dali::Devel::PixelBuffer arg2 ; - float arg3 ; - bool arg4 ; - Dali::Devel::PixelBuffer *argp2 ; - - arg1 = (Dali::Devel::PixelBuffer *)jarg1; - argp2 = (Dali::Devel::PixelBuffer *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0); - return ; - } - arg2 = *argp2; - arg3 = (float)jarg3; - arg4 = jarg4 ? true : false; - { - try { - (arg1)->ApplyMask(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) { - Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; - Dali::Devel::PixelBuffer arg2 ; - float arg3 ; - Dali::Devel::PixelBuffer *argp2 ; - - arg1 = (Dali::Devel::PixelBuffer *)jarg1; - argp2 = (Dali::Devel::PixelBuffer *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0); - return ; - } - arg2 = *argp2; - arg3 = (float)jarg3; - { - try { - (arg1)->ApplyMask(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) { - Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; - Dali::Devel::PixelBuffer arg2 ; - Dali::Devel::PixelBuffer *argp2 ; - - arg1 = (Dali::Devel::PixelBuffer *)jarg1; - argp2 = (Dali::Devel::PixelBuffer *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->ApplyMask(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) { - Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; - float arg2 ; - - arg1 = (Dali::Devel::PixelBuffer *)jarg1; - arg2 = (float)jarg2; - { - try { - (arg1)->ApplyGaussianBlur(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) { - Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; - uint16_t arg2 ; - uint16_t arg3 ; - uint16_t arg4 ; - uint16_t arg5 ; - - arg1 = (Dali::Devel::PixelBuffer *)jarg1; - arg2 = (uint16_t)jarg2; - arg3 = (uint16_t)jarg3; - arg4 = (uint16_t)jarg4; - arg5 = (uint16_t)jarg5; - { - try { - (arg1)->Crop(arg2,arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) { - Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; - uint16_t arg2 ; - uint16_t arg3 ; - - arg1 = (Dali::Devel::PixelBuffer *)jarg1; - arg2 = (uint16_t)jarg2; - arg3 = (uint16_t)jarg3; - { - try { - (arg1)->Resize(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void* jarg2) { - Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; - Dali::Degree * arg2 ; - - bool result = false; - - arg1 = (Dali::Devel::PixelBuffer *)jarg1; - arg2 = (Dali::Degree *)jarg2; - { - try { - result = (arg1)->Rotate(*arg2); - } CALL_CATCH_EXCEPTION(false); - } - return result; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBrightness(void * jarg1) { - Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ; - uint32_t result = 0; - - arg1 = (Dali::Devel::PixelBuffer *)jarg1; - { - try { - result = (arg1)->GetBrightness(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::ImageDimensions arg2 ; - Dali::FittingMode::Type arg3 ; - Dali::SamplingMode::Type arg4 ; - bool arg5 ; - Dali::ImageDimensions *argp2 ; - Dali::Devel::PixelBuffer result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - argp2 = (Dali::ImageDimensions *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg2 = *argp2; - arg3 = (Dali::FittingMode::Type)jarg3; - arg4 = (Dali::SamplingMode::Type)jarg4; - arg5 = jarg5 ? true : false; - { - try { - result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::ImageDimensions arg2 ; - Dali::FittingMode::Type arg3 ; - Dali::SamplingMode::Type arg4 ; - Dali::ImageDimensions *argp2 ; - Dali::Devel::PixelBuffer result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - argp2 = (Dali::ImageDimensions *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg2 = *argp2; - arg3 = (Dali::FittingMode::Type)jarg3; - arg4 = (Dali::SamplingMode::Type)jarg4; - { - try { - result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::ImageDimensions arg2 ; - Dali::FittingMode::Type arg3 ; - Dali::ImageDimensions *argp2 ; - Dali::Devel::PixelBuffer result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - argp2 = (Dali::ImageDimensions *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg2 = *argp2; - arg3 = (Dali::FittingMode::Type)jarg3; - { - try { - result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::ImageDimensions arg2 ; - Dali::ImageDimensions *argp2 ; - Dali::Devel::PixelBuffer result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - argp2 = (Dali::ImageDimensions *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::Devel::PixelBuffer result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - { - try { - result = Dali::LoadImageFromFile((std::string const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_0(void * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) { - void * jresult ; - Dali::Vector *arg1 = (Dali::Vector *) 0; - Dali::ImageDimensions arg2 ; - Dali::FittingMode::Type arg3 ; - Dali::SamplingMode::Type arg4 ; - bool arg5 ; - Dali::ImageDimensions *argp2 ; - Dali::Devel::PixelBuffer result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0); - return 0; - } - arg1 = (Dali::Vector *)jarg1; - argp2 = (Dali::ImageDimensions *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg2 = *argp2; - arg3 = (Dali::FittingMode::Type)jarg3; - arg4 = (Dali::SamplingMode::Type)jarg4; - arg5 = jarg5 ? true : false; - { - try { - result = Dali::LoadImageFromBuffer((const Dali::Vector&)*arg1, arg2, arg3, arg4, arg5); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_1(void * jarg1, void * jarg2, int jarg3, int jarg4) { - void * jresult ; - Dali::Vector *arg1 = (Dali::Vector *) 0; - Dali::ImageDimensions arg2 ; - Dali::FittingMode::Type arg3 ; - Dali::SamplingMode::Type arg4 ; - Dali::ImageDimensions *argp2 ; - Dali::Devel::PixelBuffer result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0); - return 0; - } - arg1 = (Dali::Vector *)jarg1; - argp2 = (Dali::ImageDimensions *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg2 = *argp2; - arg3 = (Dali::FittingMode::Type)jarg3; - arg4 = (Dali::SamplingMode::Type)jarg4; - { - try { - result = Dali::LoadImageFromBuffer((const Dali::Vector&)*arg1, arg2, arg3, arg4); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_2(void * jarg1, void * jarg2, int jarg3) { - void * jresult ; - Dali::Vector *arg1 = (Dali::Vector *) 0; - Dali::ImageDimensions arg2 ; - Dali::FittingMode::Type arg3 ; - Dali::ImageDimensions *argp2 ; - Dali::Devel::PixelBuffer result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0); - return 0; - } - arg1 = (Dali::Vector *)jarg1; - argp2 = (Dali::ImageDimensions *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg2 = *argp2; - arg3 = (Dali::FittingMode::Type)jarg3; - { - try { - result = Dali::LoadImageFromBuffer((const Dali::Vector&)*arg1, arg2, arg3); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_3(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector *arg1 = (Dali::Vector *) 0; - Dali::ImageDimensions arg2 ; - Dali::ImageDimensions *argp2 ; - Dali::Devel::PixelBuffer result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0); - return 0; - } - arg1 = (Dali::Vector *)jarg1; - argp2 = (Dali::ImageDimensions *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = Dali::LoadImageFromBuffer((const Dali::Vector&)*arg1, arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromBuffer__SWIG_4(void * jarg1) { - void * jresult ; - Dali::Vector *arg1 = (Dali::Vector *) 0; - Dali::Devel::PixelBuffer result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0); - return 0; - } - arg1 = (Dali::Vector *)jarg1; - { - try { - result = Dali::LoadImageFromBuffer((const Dali::Vector&)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::ImageDimensions arg2 ; - Dali::FittingMode::Type arg3 ; - Dali::SamplingMode::Type arg4 ; - bool arg5 ; - Dali::ImageDimensions *argp2 ; - Dali::ImageDimensions result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - argp2 = (Dali::ImageDimensions *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg2 = *argp2; - arg3 = (Dali::FittingMode::Type)jarg3; - arg4 = (Dali::SamplingMode::Type)jarg4; - arg5 = jarg5 ? true : false; - { - try { - result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::ImageDimensions arg2 ; - Dali::FittingMode::Type arg3 ; - Dali::SamplingMode::Type arg4 ; - Dali::ImageDimensions *argp2 ; - Dali::ImageDimensions result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - argp2 = (Dali::ImageDimensions *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg2 = *argp2; - arg3 = (Dali::FittingMode::Type)jarg3; - arg4 = (Dali::SamplingMode::Type)jarg4; - { - try { - result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::ImageDimensions arg2 ; - Dali::FittingMode::Type arg3 ; - Dali::ImageDimensions *argp2 ; - Dali::ImageDimensions result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - argp2 = (Dali::ImageDimensions *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg2 = *argp2; - arg3 = (Dali::FittingMode::Type)jarg3; - { - try { - result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::ImageDimensions arg2 ; - Dali::ImageDimensions *argp2 ; - Dali::ImageDimensions result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - argp2 = (Dali::ImageDimensions *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::ImageDimensions result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - { - try { - result = Dali::GetClosestImageSize((std::string const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1, bool jarg2) { - void * jresult ; - std::string *arg1 = 0 ; - bool arg2 ; - Dali::ImageDimensions result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - arg2 = jarg2 ? true : false; - { - try { - result = Dali::GetOriginalImageSize((std::string const &)*arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, bool jarg5) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::ImageDimensions arg2 ; - Dali::FittingMode::Type arg3 ; - Dali::SamplingMode::Type arg4 ; - bool arg5 ; - Dali::ImageDimensions *argp2 ; - Dali::Devel::PixelBuffer result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - argp2 = (Dali::ImageDimensions *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg2 = *argp2; - arg3 = (Dali::FittingMode::Type)jarg3; - arg4 = (Dali::SamplingMode::Type)jarg4; - arg5 = jarg5 ? true : false; - { - try { - result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::ImageDimensions arg2 ; - Dali::FittingMode::Type arg3 ; - Dali::SamplingMode::Type arg4 ; - Dali::ImageDimensions *argp2 ; - Dali::Devel::PixelBuffer result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - argp2 = (Dali::ImageDimensions *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg2 = *argp2; - arg3 = (Dali::FittingMode::Type)jarg3; - arg4 = (Dali::SamplingMode::Type)jarg4; - { - try { - result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::ImageDimensions arg2 ; - Dali::FittingMode::Type arg3 ; - Dali::ImageDimensions *argp2 ; - Dali::Devel::PixelBuffer result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - argp2 = (Dali::ImageDimensions *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg2 = *argp2; - arg3 = (Dali::FittingMode::Type)jarg3; - { - try { - result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::ImageDimensions arg2 ; - Dali::ImageDimensions *argp2 ; - Dali::Devel::PixelBuffer result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - argp2 = (Dali::ImageDimensions *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) { - void * jresult ; - std::string *arg1 = 0 ; - Dali::Devel::PixelBuffer result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - { - try { - result = Dali::DownloadImageSynchronously((std::string const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) { - const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1); - char * jresult = SWIG_csharp_string_callback((const char *)result); - return jresult; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) { - bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2); - return result; -} - -struct NativeImageSourcePtrHandle -{ - NativeImageSourcePtr Ptr; -}; - -SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1) -{ - NativeImageSource* arg1 = (NativeImageSource*)jarg1; - return (NativeImageInterface*)(arg1); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3) -{ - void* jresult; - NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle(); - { - try { - handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) ); - } - catch (std::out_of_range & e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } - catch (std::exception & e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } - catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } - catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - jresult = (void *)handle; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1) -{ - void* jresult; - NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1; - jresult = (void*)( handle->Ptr.Get() ); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) { - NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1; - { - try { - delete arg1; - } - catch (std::out_of_range & e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return; - }; - } - catch (std::exception & e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return; - }; - } - catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return; - }; - } - catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return; - }; - } - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4) -{ - void* jresult; - NativeImageSource* arg1 = (NativeImageSource*)jarg1; - uint32_t* arg2 = (uint32_t*)(jarg2); - uint32_t* arg3 = (uint32_t*)(jarg3); - uint32_t* arg4 = (uint32_t*)(jarg4); - { - try { - jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 ); - } - catch (std::out_of_range & e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } - catch (std::exception & e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } - catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } - catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - return jresult; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1) -{ - bool jresult; - NativeImageSource* arg1 = (NativeImageSource*)jarg1; - - { - try { - jresult = Dali::DevelNativeImageSource::ReleaseBuffer(*arg1, Rect{}); - } - catch (std::out_of_range & e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } - catch (std::exception & e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } - catch (Dali::DaliException e) { - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } - catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_GenerateUrl(void* handle) -{ - Dali::Toolkit::ImageUrl result; - NativeImageSource* nativeImageSource = (NativeImageSource*)handle; - void *jresult; - - if (!nativeImageSource) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); - return 0; - } - { - try - { - result = Dali::Toolkit::Image::GenerateUrl(nativeImageSource); - } - catch (std::out_of_range& e) - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); - return 0; - } - catch (std::exception& e) - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); - return 0; - } - catch (Dali::DaliException e) - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); - return 0; - } - catch (...) - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); - return 0; - } - } - - jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_EnableBackBuffer(void* nativeImageHandle, bool enable) -{ - NativeImageSource* nativeImage = static_cast(nativeImageHandle); - - if(!nativeImage) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "nativeImageHandle is null", 0); - return; - } - { - try - { - Dali::DevelNativeImageSource::EnableBackBuffer(*nativeImage, enable); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageUrl(void* jarg1) -{ - Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0; - - imageUrl = (Dali::Toolkit::ImageUrl*)jarg1; - { - try - { - delete imageUrl; - } - catch (std::out_of_range& e) - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); - return; - } - catch (std::exception& e) - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); - return; - } - catch (Dali::DaliException e) - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); - return; - } - catch (...) - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); - return; - } - } -} - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImageUrl_Get(void* jarg1) -{ - char *jresult; - Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0; - std::string result; - - imageUrl = (Dali::Toolkit::ImageUrl*)jarg1; - { - try - { - result = imageUrl->GetUrl(); - } - catch (std::out_of_range& e) - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); - return 0; - } - catch (std::exception& e) - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); - return 0; - } - catch (Dali::DaliException e) - { - SWIG_CSharpException(SWIG_UnknownError, e.condition); - return 0; - } - catch (...) - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); - return 0; - } - } - - jresult = SWIG_csharp_string_callback((&result)->c_str()); - return jresult; -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetSuggestedMinimumWidth(void * jarg1) { - Dali::Actor *arg1 = (Dali::Actor *) 0; - Dali::Vector2 maximumSize; - Dali::Vector2 minimumSize; - Dali::Vector3 naturalSize; - bool widthForHeight; - float result; - { - try { - arg1 = (Dali::Actor *)jarg1; - maximumSize = arg1->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE ); - minimumSize = arg1->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE ); - naturalSize = arg1->GetNaturalSize(); - widthForHeight = arg1->GetProperty< bool >( Actor::Property::WIDTH_FOR_HEIGHT ); - - float baseWidth; - if (widthForHeight) - { - float baseHeight = maximumSize.height > 0 ? std::min(maximumSize.height, naturalSize.height) : naturalSize.height; - baseWidth = arg1->GetWidthForHeight(baseHeight); - } - else - { - baseWidth = naturalSize.width; - } - - result = minimumSize.width > 0 ? std::max(baseWidth, minimumSize.width) : baseWidth; - result = maximumSize.width > 0 ? std::min(result, maximumSize.width) : result; - } CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetSuggestedMinimumHeight(void * jarg1) { - Dali::Actor *arg1 = (Dali::Actor *) 0; - Dali::Vector2 maximumSize; - Dali::Vector2 minimumSize; - Dali::Vector3 naturalSize; - bool heightForWidth; - float result; - { - try { - arg1 = (Dali::Actor *)jarg1; - maximumSize = arg1->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE ); - minimumSize = arg1->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE ); - naturalSize = arg1->GetNaturalSize(); - heightForWidth = arg1->GetProperty< bool >( Actor::Property::HEIGHT_FOR_WIDTH ); - - float baseHeight; - if (heightForWidth) - { - float baseWidth = maximumSize.width > 0 ? std::min(maximumSize.width, naturalSize.width) : naturalSize.width; - baseHeight = arg1->GetHeightForWidth(baseWidth); - } - else - { - baseHeight = naturalSize.height; - } - - result = minimumSize.height > 0 ? std::max(baseHeight, minimumSize.height) : baseHeight; - result = maximumSize.height > 0 ? std::min(result, maximumSize.height) : result; - } CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorVector2_BaseType_get() { - int jresult ; - int result; - - result = (int)Dali::Vector< Dali::Vector2 >::BaseType; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorVector2__SWIG_0() { - void * jresult ; - Dali::Vector< Dali::Vector2 > *result = 0 ; - - { - try { - result = (Dali::Vector< Dali::Vector2 > *)new Dali::Vector< Dali::Vector2 >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorVector2(void * jarg1) { - Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; - - arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorVector2__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Vector< Dali::Vector2 > *arg1 = 0 ; - Dali::Vector< Dali::Vector2 > *result = 0 ; - - arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector< Dali::Vector2 > *)new Dali::Vector< Dali::Vector2 >((Dali::Vector< Dali::Vector2 > const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; - Dali::Vector< Dali::Vector2 > *arg2 = 0 ; - Dali::Vector< Dali::Vector2 > *result = 0 ; - - arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; - arg2 = (Dali::Vector< Dali::Vector2 > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector< Dali::Vector2 > *) &(arg1)->operator =((Dali::Vector< Dali::Vector2 > const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Begin(void * jarg1) { - void * jresult ; - Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; - Dali::Vector< Dali::Vector2 >::Iterator result; - - arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; - { - try { - result = (Dali::Vector< Dali::Vector2 >::Iterator)((Dali::Vector< Dali::Vector2 > const *)arg1)->Begin(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_End(void * jarg1) { - void * jresult ; - Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; - Dali::Vector< Dali::Vector2 >::Iterator result; - - arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; - { - try { - result = (Dali::Vector< Dali::Vector2 >::Iterator)((Dali::Vector< Dali::Vector2 > const *)arg1)->End(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) { - void * jresult ; - Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; - Dali::Vector< Dali::Vector2 >::SizeType arg2 ; - Dali::Vector< Dali::Vector2 >::ItemType *result = 0 ; - - arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; - arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2; - { - try { - result = (Dali::Vector< Dali::Vector2 >::ItemType *) &(arg1)->operator [](arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_PushBack(void * jarg1, void * jarg2) { - Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; - Dali::Vector< Dali::Vector2 >::ItemType *arg2 = 0 ; - - arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; - arg2 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 >::ItemType const & type is null", 0); - return ; - } - { - try { - (arg1)->PushBack((Dali::Vector< Dali::Vector2 >::ItemType const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) { - Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; - Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ; - Dali::Vector< Dali::Vector2 >::ItemType *arg3 = 0 ; - - arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; - arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2; - arg3 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 >::ItemType const & type is null", 0); - return ; - } - { - try { - (arg1)->Insert(arg2,(Dali::Vector< Dali::Vector2 >::ItemType const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) { - Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; - Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ; - Dali::Vector< Dali::Vector2 >::Iterator arg3 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ; - Dali::Vector< Dali::Vector2 >::Iterator arg4 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ; - - arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; - arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2; - arg3 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg3; - arg4 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg4; - { - try { - (arg1)->Insert(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Reserve(void * jarg1, unsigned long jarg2) { - Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; - Dali::Vector< Dali::Vector2 >::SizeType arg2 ; - - arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; - arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2; - { - try { - (arg1)->Reserve(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Resize__SWIG_0(void * jarg1, unsigned long jarg2) { - Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; - Dali::Vector< Dali::Vector2 >::SizeType arg2 ; - - arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; - arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2; - { - try { - (arg1)->Resize(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) { - Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; - Dali::Vector< Dali::Vector2 >::SizeType arg2 ; - Dali::Vector< Dali::Vector2 >::ItemType *arg3 = 0 ; - - arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; - arg2 = (Dali::Vector< Dali::Vector2 >::SizeType)jarg2; - arg3 = (Dali::Vector< Dali::Vector2 >::ItemType *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0); - return ; - } - { - try { - (arg1)->Resize(arg2,(Dali::Vector< Dali::Vector2 >::ItemType const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Erase__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; - Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ; - Dali::Vector< Dali::Vector2 >::Iterator result; - - arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; - arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2; - { - try { - result = (Dali::Vector< Dali::Vector2 >::Iterator)(arg1)->Erase(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorVector2_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) { - void * jresult ; - Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; - Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ; - Dali::Vector< Dali::Vector2 >::Iterator arg3 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ; - Dali::Vector< Dali::Vector2 >::Iterator result; - - arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; - arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2; - arg3 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg3; - { - try { - result = (Dali::Vector< Dali::Vector2 >::Iterator)(arg1)->Erase(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Remove(void * jarg1, void * jarg2) { - Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; - Dali::Vector< Dali::Vector2 >::Iterator arg2 = (Dali::Vector< Dali::Vector2 >::Iterator) 0 ; - - arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; - arg2 = (Dali::Vector< Dali::Vector2 >::Iterator)jarg2; - { - try { - (arg1)->Remove(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Swap(void * jarg1, void * jarg2) { - Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; - Dali::Vector< Dali::Vector2 > *arg2 = 0 ; - - arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; - arg2 = (Dali::Vector< Dali::Vector2 > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Vector2 > & type is null", 0); - return ; - } - { - try { - (arg1)->Swap(*arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Clear(void * jarg1) { - Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; - - arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; - { - try { - (arg1)->Clear(); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorVector2_Release(void * jarg1) { - Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; - - arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; - { - try { - (arg1)->Release(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorVector2_Size(void * jarg1) { - Dali::Vector< Dali::Vector2 > *arg1 = (Dali::Vector< Dali::Vector2 > *) 0 ; - int size; - - arg1 = (Dali::Vector< Dali::Vector2 > *)jarg1; - { - try { - size = (arg1)->Size(); - } CALL_CATCH_EXCEPTION(0); - } - - return size; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_BaseType_get() { - int jresult; - int result; - - result = (int)Dali::Vector::BaseType; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_VectorUnsignedInteger__SWIG_0() { - void *jresult; - Dali::Vector *result = 0; - - { - try { - result = (Dali::Vector *)new Dali::Vector(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_delete_VectorUnsignedInteger(void *jarg1) { - Dali::Vector *arg1 = (Dali::Vector *)0; - - arg1 = (Dali::Vector *)jarg1; - { - try { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL -CSharp_Dali_new_VectorUnsignedInteger__SWIG_1(void *jarg1) { - void *jresult; - Dali::Vector *arg1 = 0; - Dali::Vector *result = 0; - - arg1 = (Dali::Vector *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Dali::Vector< uint32_t > const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector *)new Dali::Vector( - (Dali::Vector const &)*arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void *SWIGSTDCALL -CSharp_Dali_VectorUnsignedInteger_Assign(void *jarg1, void *jarg2) { - void *jresult; - Dali::Vector *arg1 = (Dali::Vector *)0; - Dali::Vector *arg2 = 0; - Dali::Vector *result = 0; - - arg1 = (Dali::Vector *)jarg1; - arg2 = (Dali::Vector *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Dali::Vector< uint32_t > const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Vector *)&(arg1)->operator=( - (Dali::Vector const &)*arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void *SWIGSTDCALL -CSharp_Dali_VectorUnsignedInteger_Begin(void *jarg1) { - void *jresult; - Dali::Vector *arg1 = (Dali::Vector *)0; - Dali::Vector::Iterator result; - - arg1 = (Dali::Vector *)jarg1; - { - try { - result = (Dali::Vector::Iterator)( - (Dali::Vector const *)arg1) - ->Begin(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void *SWIGSTDCALL -CSharp_Dali_VectorUnsignedInteger_End(void *jarg1) { - void *jresult; - Dali::Vector *arg1 = (Dali::Vector *)0; - Dali::Vector::Iterator result; - - arg1 = (Dali::Vector *)jarg1; - { - try { - result = (Dali::Vector::Iterator)( - (Dali::Vector const *)arg1) - ->End(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void *SWIGSTDCALL -CSharp_Dali_VectorUnsignedInteger_ValueOfIndex__SWIG_0(void *jarg1, - unsigned long jarg2) { - void *jresult; - Dali::Vector *arg1 = (Dali::Vector *)0; - Dali::Vector::SizeType arg2; - Dali::Vector::ItemType *result = 0; - - arg1 = (Dali::Vector *)jarg1; - arg2 = (Dali::Vector::SizeType)jarg2; - { - try { - result = (Dali::Vector::ItemType *)&(arg1)->operator[](arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_VectorUnsignedInteger_PushBack(void *jarg1, uint32_t jarg2) { - Dali::Vector *arg1 = (Dali::Vector *)0; - Dali::Vector::ItemType *arg2 = 0; - Dali::Vector::ItemType temp2; - - arg1 = (Dali::Vector *)jarg1; - temp2 = (Dali::Vector::ItemType)jarg2; - arg2 = &temp2; - { - try { - (arg1)->PushBack((Dali::Vector::ItemType const &)*arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_Insert__SWIG_0( - void *jarg1, uint32_t *jarg2, uint32_t jarg3) { - Dali::Vector *arg1 = (Dali::Vector *)0; - Dali::Vector::Iterator arg2 = (Dali::Vector::Iterator)0; - Dali::Vector::ItemType *arg3 = 0; - Dali::Vector::ItemType temp3; - - arg1 = (Dali::Vector *)jarg1; - arg2 = jarg2; - temp3 = (Dali::Vector::ItemType)jarg3; - arg3 = &temp3; - { - try { - (arg1)->Insert(arg2, (Dali::Vector::ItemType const &)*arg3); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_Insert__SWIG_1( - void *jarg1, uint32_t *jarg2, void *jarg3, void *jarg4) { - Dali::Vector *arg1 = (Dali::Vector *)0; - Dali::Vector::Iterator arg2 = (Dali::Vector::Iterator)0; - Dali::Vector::Iterator arg3 = (Dali::Vector::Iterator)0; - Dali::Vector::Iterator arg4 = (Dali::Vector::Iterator)0; - - arg1 = (Dali::Vector *)jarg1; - arg2 = jarg2; - arg3 = (Dali::Vector::Iterator)jarg3; - arg4 = (Dali::Vector::Iterator)jarg4; - { - try { - (arg1)->Insert(arg2, arg3, arg4); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_VectorUnsignedInteger_Reserve(void *jarg1, unsigned long jarg2) { - Dali::Vector *arg1 = (Dali::Vector *)0; - Dali::Vector::SizeType arg2; - - arg1 = (Dali::Vector *)jarg1; - arg2 = (Dali::Vector::SizeType)jarg2; - { - try { - (arg1)->Reserve(arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_Resize__SWIG_0( - void *jarg1, unsigned long jarg2) { - Dali::Vector *arg1 = (Dali::Vector *)0; - Dali::Vector::SizeType arg2; - - arg1 = (Dali::Vector *)jarg1; - arg2 = (Dali::Vector::SizeType)jarg2; - { - try { - (arg1)->Resize(arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_Resize__SWIG_1( - void *jarg1, unsigned long jarg2, uint32_t jarg3) { - Dali::Vector *arg1 = (Dali::Vector *)0; - Dali::Vector::SizeType arg2; - Dali::Vector::ItemType *arg3 = 0; - Dali::Vector::ItemType temp3; - - arg1 = (Dali::Vector *)jarg1; - arg2 = (Dali::Vector::SizeType)jarg2; - temp3 = (Dali::Vector::ItemType)jarg3; - arg3 = &temp3; - { - try { - (arg1)->Resize(arg2, (Dali::Vector::ItemType const &)*arg3); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL -CSharp_Dali_VectorUnsignedInteger_Erase__SWIG_0(void *jarg1, uint32_t *jarg2) { - void *jresult; - Dali::Vector *arg1 = (Dali::Vector *)0; - Dali::Vector::Iterator arg2 = (Dali::Vector::Iterator)0; - Dali::Vector::Iterator result; - - arg1 = (Dali::Vector *)jarg1; - arg2 = jarg2; - { - try { - result = (Dali::Vector::Iterator)(arg1)->Erase(arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - return jresult; -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_Erase__SWIG_1( - void *jarg1, uint32_t *jarg2, void *jarg3) { - void *jresult; - Dali::Vector *arg1 = (Dali::Vector *)0; - Dali::Vector::Iterator arg2 = (Dali::Vector::Iterator)0; - Dali::Vector::Iterator arg3 = (Dali::Vector::Iterator)0; - Dali::Vector::Iterator result; - - arg1 = (Dali::Vector *)jarg1; - arg2 = jarg2; - arg3 = (Dali::Vector::Iterator)jarg3; - { - try { - result = (Dali::Vector::Iterator)(arg1)->Erase(arg2, arg3); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_VectorUnsignedInteger_Remove(void *jarg1, uint32_t *jarg2) { - Dali::Vector *arg1 = (Dali::Vector *)0; - Dali::Vector::Iterator arg2 = (Dali::Vector::Iterator)0; - - arg1 = (Dali::Vector *)jarg1; - arg2 = jarg2; - { - try { - (arg1)->Remove(arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_VectorUnsignedInteger_Swap(void *jarg1, void *jarg2) { - Dali::Vector *arg1 = (Dali::Vector *)0; - Dali::Vector *arg2 = 0; - - arg1 = (Dali::Vector *)jarg1; - arg2 = (Dali::Vector *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Dali::Vector< uint32_t > & type is null", 0); - return; - } - { - try { - (arg1)->Swap(*arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_VectorUnsignedInteger_Clear(void *jarg1) { - Dali::Vector *arg1 = (Dali::Vector *)0; - - arg1 = (Dali::Vector *)jarg1; - { - try { - (arg1)->Clear(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_VectorUnsignedInteger_Release(void *jarg1) { - Dali::Vector *arg1 = (Dali::Vector *)0; - - arg1 = (Dali::Vector *)jarg1; - { - try { - (arg1)->Release(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedInteger_Size(void *jarg1) { - Dali::Vector< uint32_t > *arg1 = (Dali::Vector< uint32_t > *) 0 ; - int size; - - arg1 = (Dali::Vector *)jarg1; - { - try { - size = (arg1)->Size(); - } CALL_CATCH_EXCEPTION(0); - } - - return size; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetScreenSize() { - void * jresult ; - int width, height; - - try { - Dali::DevelWindowSystem::GetScreenSize(width, height); - } CALL_CATCH_EXCEPTION(0); - - jresult = new Dali::Size(width, height); - return jresult; -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/dali-wrap.h b/dali-csharp-binder/src/dali-wrap.h deleted file mode 100755 index 8b40df07..00000000 --- a/dali-csharp-binder/src/dali-wrap.h +++ /dev/null @@ -1,272 +0,0 @@ -/* ---------------------------------------------------------------------------- - * This file was automatically generated by SWIG (http://www.swig.org). - * Version 3.0.9 - * - * This file is not intended to be easily readable and contains a number of - * coding conventions designed to improve portability and efficiency. Do not make - * changes to this file unless you know what you are doing--modify the SWIG - * interface file instead. - * ----------------------------------------------------------------------------- */ - -#ifndef SWIG_NDalic_WRAP_H -#define SWIG_NDalic_WRAP_H - -class SwigDirector_WidgetImpl : public Dali::Internal::Adaptor::Widget, public Swig::Director { - -public: - SwigDirector_WidgetImpl(); - virtual ~SwigDirector_WidgetImpl(); - virtual void OnCreate(std::string const &contentInfo, Dali::Window window); - virtual void OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type); - virtual void OnPause(); - virtual void OnResume(); - virtual void OnResize(Dali::Window window); - virtual void OnUpdate(std::string const &contentInfo, int force); - virtual void SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback); - virtual void SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback); - - typedef void (SWIGSTDCALL* SWIG_Callback0_t)(char *, void *); - typedef void (SWIGSTDCALL* SWIG_Callback1_t)(char *, int); - typedef void (SWIGSTDCALL* SWIG_Callback2_t)(); - typedef void (SWIGSTDCALL* SWIG_Callback3_t)(); - typedef void (SWIGSTDCALL* SWIG_Callback4_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback5_t)(char *, int); - typedef void (SWIGSTDCALL* SWIG_Callback6_t)(void *, void *); - typedef void (SWIGSTDCALL* SWIG_Callback7_t)(void *, void *); - void swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected); - -private: - SWIG_Callback0_t swig_callbackOnCreate; - SWIG_Callback1_t swig_callbackOnTerminate; - SWIG_Callback2_t swig_callbackOnPause; - SWIG_Callback3_t swig_callbackOnResume; - SWIG_Callback4_t swig_callbackOnResize; - SWIG_Callback5_t swig_callbackOnUpdate; - SWIG_Callback6_t swig_callbackSignalConnected; - SWIG_Callback7_t swig_callbackSignalDisconnected; - void swig_init_callbacks(); -}; - -class SwigDirector_ViewImpl : public Dali::Toolkit::Internal::Control, public Swig::Director { - -public: - SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags); - virtual ~SwigDirector_ViewImpl(); - virtual void OnSceneConnection(int depth); - virtual void OnSceneConnectionSwigPublic(int depth) { - Dali::Toolkit::Internal::Control::OnSceneConnection(depth); - } - virtual void OnSceneDisconnection(); - virtual void OnSceneDisconnectionSwigPublic() { - Dali::Toolkit::Internal::Control::OnSceneDisconnection(); - } - virtual void OnChildAdd(Dali::Actor &child); - virtual void OnChildAddSwigPublic(Dali::Actor &child) { - Dali::Toolkit::Internal::Control::OnChildAdd(child); - } - virtual void OnChildRemove(Dali::Actor &child); - virtual void OnChildRemoveSwigPublic(Dali::Actor &child) { - Dali::Toolkit::Internal::Control::OnChildRemove(child); - } - virtual void OnPropertySet(Dali::Property::Index index, const Dali::Property::Value& propertyValue); - virtual void OnPropertySetSwigPublic(Dali::Property::Index index, const Dali::Property::Value& propertyValue) { - Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue); - } - virtual void OnSizeSet(Dali::Vector3 const &targetSize); - virtual void OnSizeSetSwigPublic(Dali::Vector3 const &targetSize) { - Dali::Toolkit::Internal::Control::OnSizeSet(targetSize); - } - virtual void OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize); - virtual void OnSizeAnimationSwigPublic(Dali::Animation &animation, Dali::Vector3 const &targetSize) { - Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize); - } - virtual bool OnKeyEvent(Dali::KeyEvent const &event); - virtual bool OnKeyEventSwigPublic(Dali::KeyEvent const &event) { - return Dali::Toolkit::Internal::Control::OnKeyEvent(event); - } - virtual void OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container); - virtual void OnRelayoutSwigPublic(Dali::Vector2 const &size, Dali::RelayoutContainer &container) { - Dali::Toolkit::Internal::Control::OnRelayout(size,container); - } - virtual void OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension); - virtual void OnSetResizePolicySwigPublic(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) { - Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension); - } - virtual Dali::Vector3 GetNaturalSize(); - virtual Dali::Vector3 GetNaturalSizeSwigPublic() { - return Dali::Toolkit::Internal::Control::GetNaturalSize(); - } - virtual float CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension); - virtual float CalculateChildSizeSwigPublic(Dali::Actor const &child, Dali::Dimension::Type dimension) { - return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension); - } - virtual float GetHeightForWidth(float width); - virtual float GetHeightForWidthSwigPublic(float width) { - return Dali::Toolkit::Internal::Control::GetHeightForWidth(width); - } - virtual float GetWidthForHeight(float height); - virtual float GetWidthForHeightSwigPublic(float height) { - return Dali::Toolkit::Internal::Control::GetWidthForHeight(height); - } - virtual bool RelayoutDependentOnChildren(Dali::Dimension::Type dimension = Dali::Dimension::ALL_DIMENSIONS); - virtual bool RelayoutDependentOnChildrenSwigPublic(Dali::Dimension::Type dimension = Dali::Dimension::ALL_DIMENSIONS) { - return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension); - } - virtual void OnCalculateRelayoutSize(Dali::Dimension::Type dimension); - virtual void OnCalculateRelayoutSizeSwigPublic(Dali::Dimension::Type dimension) { - Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension); - } - virtual void OnLayoutNegotiated(float size, Dali::Dimension::Type dimension); - virtual void OnLayoutNegotiatedSwigPublic(float size, Dali::Dimension::Type dimension) { - Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension); - } - virtual Dali::CustomActorImpl::Extension *GetExtension(); - virtual void OnInitialize(); - virtual void OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change); - virtual bool OnAccessibilityActivated(); - virtual bool OnAccessibilityPan(Dali::PanGesture gesture); - virtual bool OnAccessibilityValueChange(bool isIncrease); - virtual bool OnAccessibilityZoom(); - virtual void OnKeyInputFocusGained(); - virtual void OnKeyInputFocusLost(); - virtual Dali::Actor GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled); - virtual void OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor); - virtual bool OnKeyboardEnter(); - virtual void OnPinch(Dali::PinchGesture const &pinch); - virtual void OnPan(Dali::PanGesture const &pan); - virtual void OnTap(Dali::TapGesture const &tap); - virtual void OnLongPress(Dali::LongPressGesture const &longPress); - virtual void SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback); - virtual void SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback); - virtual Dali::Toolkit::Internal::Control::Extension *GetControlExtension(); - - typedef void (SWIGSTDCALL* SWIG_Callback0_t)(int); - typedef void (SWIGSTDCALL* SWIG_Callback1_t)(); - typedef void (SWIGSTDCALL* SWIG_Callback2_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback3_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback4_t)(int, void *); - typedef void (SWIGSTDCALL* SWIG_Callback5_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback6_t)(void *, void *); - typedef bool (SWIGSTDCALL* SWIG_Callback9_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback11_t)(void *, void *); - typedef void (SWIGSTDCALL* SWIG_Callback12_t)(int, int); - typedef void * (SWIGSTDCALL* SWIG_Callback13_t)(); - typedef float (SWIGSTDCALL* SWIG_Callback14_t)(void *, int); - typedef float (SWIGSTDCALL* SWIG_Callback15_t)(float); - typedef float (SWIGSTDCALL* SWIG_Callback16_t)(float); - typedef bool (SWIGSTDCALL* SWIG_Callback17_t)(int); - typedef bool (SWIGSTDCALL* SWIG_Callback18_t)(); - typedef void (SWIGSTDCALL* SWIG_Callback19_t)(int); - typedef void (SWIGSTDCALL* SWIG_Callback20_t)(float, int); - typedef void (SWIGSTDCALL* SWIG_Callback21_t)(); - typedef void (SWIGSTDCALL* SWIG_Callback22_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback23_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback24_t)(void *, int); - typedef bool (SWIGSTDCALL* SWIG_Callback25_t)(); - typedef bool (SWIGSTDCALL* SWIG_Callback26_t)(void *); - typedef bool (SWIGSTDCALL* SWIG_Callback28_t)(bool); - typedef bool (SWIGSTDCALL* SWIG_Callback29_t)(); - typedef void (SWIGSTDCALL* SWIG_Callback30_t)(); - typedef void (SWIGSTDCALL* SWIG_Callback31_t)(); - typedef void * (SWIGSTDCALL* SWIG_Callback32_t)(void *, int, bool); - typedef void (SWIGSTDCALL* SWIG_Callback33_t)(void *); - typedef bool (SWIGSTDCALL* SWIG_Callback34_t)(); - typedef void (SWIGSTDCALL* SWIG_Callback35_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback36_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback37_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback38_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback39_t)(void *, void *); - typedef void (SWIGSTDCALL* SWIG_Callback40_t)(void *, void *); - void swig_connect_director(SWIG_Callback0_t callbackOnSceneConnection, SWIG_Callback1_t callbackOnSceneDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected); - -private: - SWIG_Callback0_t swig_callbackOnSceneConnection; - SWIG_Callback1_t swig_callbackOnSceneDisconnection; - SWIG_Callback2_t swig_callbackOnChildAdd; - SWIG_Callback3_t swig_callbackOnChildRemove; - SWIG_Callback4_t swig_callbackOnPropertySet; - SWIG_Callback5_t swig_callbackOnSizeSet; - SWIG_Callback6_t swig_callbackOnSizeAnimation; - SWIG_Callback9_t swig_callbackOnKeyEvent; - SWIG_Callback11_t swig_callbackOnRelayout; - SWIG_Callback12_t swig_callbackOnSetResizePolicy; - SWIG_Callback13_t swig_callbackGetNaturalSize; - SWIG_Callback14_t swig_callbackCalculateChildSize; - SWIG_Callback15_t swig_callbackGetHeightForWidth; - SWIG_Callback16_t swig_callbackGetWidthForHeight; - SWIG_Callback17_t swig_callbackRelayoutDependentOnChildren__SWIG_0; - SWIG_Callback18_t swig_callbackRelayoutDependentOnChildren__SWIG_1; - SWIG_Callback19_t swig_callbackOnCalculateRelayoutSize; - SWIG_Callback20_t swig_callbackOnLayoutNegotiated; - SWIG_Callback21_t swig_callbackOnInitialize; - SWIG_Callback24_t swig_callbackOnStyleChange; - SWIG_Callback25_t swig_callbackOnAccessibilityActivated; - SWIG_Callback26_t swig_callbackOnAccessibilityPan; - SWIG_Callback28_t swig_callbackOnAccessibilityValueChange; - SWIG_Callback29_t swig_callbackOnAccessibilityZoom; - SWIG_Callback30_t swig_callbackOnKeyInputFocusGained; - SWIG_Callback31_t swig_callbackOnKeyInputFocusLost; - SWIG_Callback32_t swig_callbackGetNextKeyboardFocusableActor; - SWIG_Callback33_t swig_callbackOnKeyboardFocusChangeCommitted; - SWIG_Callback34_t swig_callbackOnKeyboardEnter; - SWIG_Callback35_t swig_callbackOnPinch; - SWIG_Callback36_t swig_callbackOnPan; - SWIG_Callback37_t swig_callbackOnTap; - SWIG_Callback38_t swig_callbackOnLongPress; - SWIG_Callback39_t swig_callbackSignalConnected; - SWIG_Callback40_t swig_callbackSignalDisconnected; - void swig_init_callbacks(); -}; - -class SwigDirector_ItemFactory : public Dali::Toolkit::ItemFactory, public Swig::Director { - -public: - SwigDirector_ItemFactory(); - virtual ~SwigDirector_ItemFactory(); - virtual unsigned int GetNumberOfItems(); - virtual Dali::Actor NewItem(unsigned int itemId); - virtual void ItemReleased(unsigned int itemId, Dali::Actor actor); - virtual Dali::Toolkit::ItemFactory::Extension *GetExtension(); - - typedef unsigned int (SWIGSTDCALL* SWIG_Callback0_t)(); - typedef void * (SWIGSTDCALL* SWIG_Callback1_t)(unsigned int); - typedef void (SWIGSTDCALL* SWIG_Callback2_t)(unsigned int, void *); - void swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased); - -private: - SWIG_Callback0_t swig_callbackGetNumberOfItems; - SWIG_Callback1_t swig_callbackNewItem; - SWIG_Callback2_t swig_callbackItemReleased; - void swig_init_callbacks(); -}; - -class SwigDirector_CustomAlgorithmInterface : public Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface, public Swig::Director { - -public: - SwigDirector_CustomAlgorithmInterface(); - virtual ~SwigDirector_CustomAlgorithmInterface(); - virtual Dali::Actor GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction, const std::string& deviceName = ""); - - typedef void * (SWIGSTDCALL* SWIG_Callback0_t)(void *, void *, int, const char*); - void swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor); - -private: - SWIG_Callback0_t swig_callbackGetNextFocusableActor; - void swig_init_callbacks(); -}; - -class SwigDirector_FrameCallbackInterface : public Dali::FrameCallbackInterface, public Swig::Director { -public: - SwigDirector_FrameCallbackInterface(); - virtual ~SwigDirector_FrameCallbackInterface(); - virtual bool Update( Dali::UpdateProxy& updateProxy, float elapsedSeconds ); - - typedef void (SWIGSTDCALL* SWIG_Callback0_t)( void* updateProxy, float elapsedSeconds ); - void swig_connect_director( SWIG_Callback0_t callbackUpdate ); - - -private: - SWIG_Callback0_t swig_callbackOnUpdate; -}; - -#endif diff --git a/dali-csharp-binder/src/devel-property-wrap.cpp b/dali-csharp-binder/src/devel-property-wrap.cpp deleted file mode 100755 index e40ca690..00000000 --- a/dali-csharp-binder/src/devel-property-wrap.cpp +++ /dev/null @@ -1,628 +0,0 @@ -/* - * Copyright (c) 2020 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - - -// INTERNAL INCLUDES -#include "common.h" - -using namespace Dali; -using namespace Dali::Toolkit; -using signalType = DevelControl::VisualEventSignalType; -using visualSignalType = - Signal; -using SignalCallbackFuncType = void (*)(Control, Property::Index, - Property::Index); - -SWIGINTERN bool _CSharp_Dali_VisualEventSignal_Empty(signalType const *self) { - return self->Empty(); -} -SWIGINTERN std::size_t -_CSharp_Dali_VisualEventSignal_GetConnectionCount(signalType *self) { - return self->GetConnectionCount(); -} -SWIGINTERN void -_CSharp_Dali_VisualEventSignal_Connect(signalType *self, - SignalCallbackFuncType func) { - self->Connect(func); -} -SWIGINTERN void -_CSharp_Dali_VisualEventSignal_Disconnect(signalType *self, - SignalCallbackFuncType func) { - self->Disconnect(func); -} -SWIGINTERN void _CSharp_Dali_VisualEventSignal_Emit(signalType *self, - Control arg1, - Property::Index arg2, - Property::Index arg3) { - self->Emit(arg1, arg2, arg3); -} - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SIBLING_ORDER_get() { - - return Dali::DevelActor::Property::SIBLING_ORDER; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Actor_Property_CAPTURE_ALL_TOUCH_AFTER_START_get() { - - return Dali::DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Actor_Property_ALLOW_ONLY_OWN_TOUCH_get() { - - return Dali::DevelActor::Property::ALLOW_ONLY_OWN_TOUCH; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_BLEND_EQUATION_get() { - - return Dali::DevelActor::Property::BLEND_EQUATION; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_TOOLTIP_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelControl::Property::TOOLTIP; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_STATE_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelControl::Property::STATE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_SUB_STATE_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelControl::Property::SUB_STATE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_LEFT_FOCUSABLE_ACTOR_ID_get() { - return Dali::Toolkit::DevelControl::Property::LEFT_FOCUSABLE_ACTOR_ID; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_RIGHT_FOCUSABLE_ACTOR_ID_get() { - return Dali::Toolkit::DevelControl::Property::RIGHT_FOCUSABLE_ACTOR_ID; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_UP_FOCUSABLE_ACTOR_ID_get() { - return Dali::Toolkit::DevelControl::Property::UP_FOCUSABLE_ACTOR_ID; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_DOWN_FOCUSABLE_ACTOR_ID_get() { - return Dali::Toolkit::DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_CLOCKWISE_FOCUSABLE_ACTOR_ID_get() { - return Dali::Toolkit::DevelControl::Property::CLOCKWISE_FOCUSABLE_ACTOR_ID; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_View_Property_COUNTER_CLOCKWISE_FOCUSABLE_ACTOR_ID_get() { - return Dali::Toolkit::DevelControl::Property::COUNTER_CLOCKWISE_FOCUSABLE_ACTOR_ID; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_ItemView_Property_LAYOUT_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::ItemView::Property::LAYOUT; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Visual_Property_TRANSFORM_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::Visual::Property::TRANSFORM; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Visual_Property_PREMULTIPLIED_ALPHA_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::Visual::Property::PREMULTIPLIED_ALPHA; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Visual_Property_MIX_COLOR_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::Visual::Property::MIX_COLOR; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextLabel_Property_PIXEL_SIZE_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::PIXEL_SIZE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextLabel_Property_ELLIPSIS_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::ELLIPSIS; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_TextLabel_Property_AUTO_SCROLL_STOP_MODE_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_STOP_MODE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_TextLabel_Property_AUTO_SCROLL_LOOP_DELAY_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_DELAY; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_HIDDENINPUT_PROPERTY_MODE_get() { - int jresult; - int result; - - { - try { - result = (int)Dali::Toolkit::HiddenInput::Property::MODE; - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_HIDDENINPUT_PROPERTY_SUBSTITUTE_CHARACTER_get() { - int jresult; - int result; - - { - try { - result = (int)Dali::Toolkit::HiddenInput::Property::SUBSTITUTE_CHARACTER; - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_HIDDENINPUT_PROPERTY_SUBSTITUTE_COUNT_get() { - int jresult; - int result; - - { - try { - result = (int)Dali::Toolkit::HiddenInput::Property::SUBSTITUTE_COUNT; - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_HIDDENINPUT_PROPERTY_SHOW_LAST_CHARACTER_DURATION_get() { - int jresult; - int result; - - { - try { - result = (int) - Dali::Toolkit::HiddenInput::Property::SHOW_LAST_CHARACTER_DURATION; - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextLabel_Property_LINE_COUNT_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::LINE_COUNT; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextLabel_Property_LINE_WRAP_MODE_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::TextLabel::Property::LINE_WRAP_MODE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextLabel_Property_TEXT_DIRECTION_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelTextLabel::Property::TEXT_DIRECTION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_TextLabel_Property_VERTICAL_LINE_ALIGNMENT_get() { - int jresult; - int result; - - result = - (int)Dali::Toolkit::DevelTextLabel::Property::VERTICAL_LINE_ALIGNMENT; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_TextLabel_Property_MATCH_SYSTEM_LANGUAGE_DIRECTION_get() { - int jresult; - int result; - - result = (int) - Dali::Toolkit::DevelTextLabel::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextLabel_Property_MIN_LINE_SIZE_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelTextLabel::Property::MIN_LINE_SIZE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelTextLabel::Property::RENDERING_BACKEND; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextLabel_Property_ELLIPSIS_POSITION_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelTextLabel::Property::ELLIPSIS_POSITION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_LINE_WRAP_MODE_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::LINE_WRAP_MODE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_ELLIPSIS_POSITION_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::ELLIPSIS_POSITION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_MIN_LINE_SIZE_get() { - return (int)Dali::Toolkit::DevelTextEditor::Property::MIN_LINE_SIZE; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_ELLIPSIS_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::ELLIPSIS; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_ELLIPSIS_POSITION_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelTextField::Property::ELLIPSIS_POSITION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_STRIKETHROUGH_get() { - return (int)Dali::Toolkit::DevelTextEditor::Property::STRIKETHROUGH; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_STRIKETHROUGH_get() { - return (int)Dali::Toolkit::DevelTextField::Property::STRIKETHROUGH; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_STRIKETHROUGH_get() { - return (int)Dali::Toolkit::DevelTextLabel::Property::STRIKETHROUGH; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Dali_TextEditor_Property_CHARACTER_SPACING_get() { - return (int)Dali::Toolkit::DevelTextEditor::Property::CHARACTER_SPACING; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Dali_TextField_Property_CHARACTER_SPACING_get() { - return (int)Dali::Toolkit::DevelTextField::Property::CHARACTER_SPACING; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Dali_TextLabel_Property_CHARACTER_SPACING_get() { - return (int)Dali::Toolkit::DevelTextLabel::Property::CHARACTER_SPACING; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Dali_TextSelectionPopup_Property_POPUP_MAX_SIZE_get() { - return (int)Dali::Toolkit::TextSelectionPopup::Property::POPUP_MAX_SIZE; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Dali_TextSelectionPopup_Property_OPTION_DIVIDER_SIZE_get() { - return (int)Dali::Toolkit::TextSelectionPopup::Property::OPTION_DIVIDER_SIZE; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Dali_TextSelectionPopup_Property_OPTION_DIVIDER_PADDING_get() { - return (int)Dali::Toolkit::TextSelectionPopup::Property::OPTION_DIVIDER_PADDING; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Dali_TextSelectionPopup_Property_LABEL_MINIMUM_SIZE_get() { - return (int)Dali::Toolkit::TextSelectionPopup::Property::LABEL_MINIMUM_SIZE; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Dali_TextSelectionPopup_Property_LABEL_PADDING_get() { - return (int)Dali::Toolkit::TextSelectionPopup::Property::LABEL_PADDING; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Dali_TextSelectionPopup_Property_LABEL_TEXT_VISUAL_get() { - return (int)Dali::Toolkit::TextSelectionPopup::Property::LABEL_TEXT_VISUAL; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Dali_TextSelectionPopup_Property_ENABLE_SCROLL_BAR_get() { - return (int)Dali::Toolkit::TextSelectionPopup::Property::ENABLE_SCROLL_BAR; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Dali_TextSelectionPopup_Property_POPUP_DIVIDER_COLOR_get() { - return (int)Dali::Toolkit::TextSelectionPopup::Property::POPUP_DIVIDER_COLOR; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Dali_TextSelectionPopup_Property_POPUP_PRESSED_COLOR_get() { - return (int)Dali::Toolkit::TextSelectionPopup::Property::POPUP_PRESSED_COLOR; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Dali_TextSelectionPopup_Property_POPUP_PRESSED_CORNER_RADIUS_get() { - return (int)Dali::Toolkit::TextSelectionPopup::Property::POPUP_PRESSED_CORNER_RADIUS; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Dali_TextSelectionPopup_Property_POPUP_FADE_IN_DURATION_get() { - return (int)Dali::Toolkit::TextSelectionPopup::Property::POPUP_FADE_IN_DURATION; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Dali_TextSelectionPopup_Property_POPUP_FADE_OUT_DURATION_get() { - return (int)Dali::Toolkit::TextSelectionPopup::Property::POPUP_FADE_OUT_DURATION; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Dali_TextSelectionPopup_Property_BACKGROUND_get() { - return (int)Dali::Toolkit::TextSelectionPopup::Property::BACKGROUND; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Dali_TextSelectionPopup_Property_BACKGROUND_BORDER_get() { - return (int)Dali::Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER; -} - -SWIGEXPORT unsigned int SWIGSTDCALL -CSharp_Dali_VisualEventSignal_Empty(void *jarg1) { - unsigned int jresult; - signalType *arg1 = (signalType *)0; - bool result; - - arg1 = (signalType *)jarg1; - { - try { - result = (bool)_CSharp_Dali_VisualEventSignal_Empty((signalType *)arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT unsigned long SWIGSTDCALL -CSharp_Dali_VisualEventSignal_GetConnectionCount(void *jarg1) { - unsigned long jresult; - signalType *arg1 = (signalType *)0; - std::size_t result; - - arg1 = (signalType *)jarg1; - { - try { - result = - _CSharp_Dali_VisualEventSignal_GetConnectionCount((signalType *)arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualEventSignal_Connect(void *jarg1, - void *jarg2) { - signalType *arg1 = (signalType *)0; - SignalCallbackFuncType arg2 = (SignalCallbackFuncType)0; - - arg1 = (signalType *)jarg1; - arg2 = (SignalCallbackFuncType)jarg2; - { - try { - _CSharp_Dali_VisualEventSignal_Connect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_VisualEventSignal_Disconnect(void *jarg1, void *jarg2) { - signalType *arg1 = (signalType *)0; - SignalCallbackFuncType arg2 = (SignalCallbackFuncType)0; - - arg1 = (signalType *)jarg1; - arg2 = (SignalCallbackFuncType)jarg2; - { - try { - _CSharp_Dali_VisualEventSignal_Disconnect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualEventSignal_Emit(void *jarg1, - void *jarg2, - int jarg3, - int jarg4) { - signalType *arg1 = (signalType *)0; - Control *arg2 = (Control *)0; - Dali::Property::Index arg3 = 0; - Dali::Property::Index arg4 = 0; - - arg1 = (signalType *)jarg1; - arg2 = (Control *)jarg2; - arg3 = (Dali::Property::Index)jarg3; - arg4 = (Dali::Property::Index)jarg4; - { - try { - _CSharp_Dali_VisualEventSignal_Emit(arg1, *arg2, arg3, arg4); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_VisualEventSignal() { - void *jresult; - signalType *result = 0; - - { - try { - result = (signalType *)new Dali::Signal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualEventSignal(void *jarg1) { - signalType *arg1 = (signalType *)0; - - arg1 = (signalType *)jarg1; - { - try { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_View_VisualEventSignal(void *jarg1) { - void *jresult; - Control *arg1 = (Dali::Toolkit::Control *)0; - visualSignalType *result; - - arg1 = (Dali::Toolkit::Control *)jarg1; - { - try { - result = (visualSignalType *)&(DevelControl::VisualEventSignal(*arg1)); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)(result); - return jresult; -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/drag-and-drop-wrap.cpp b/dali-csharp-binder/src/drag-and-drop-wrap.cpp deleted file mode 100644 index ab6c7a8c..00000000 --- a/dali-csharp-binder/src/drag-and-drop-wrap.cpp +++ /dev/null @@ -1,252 +0,0 @@ -/* - * Copyright (c) 2022 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - -#define SWIGSTDCALL - -// INCLUDES -#include "common.h" -#include -#include - -using namespace Dali; - -/* Callback for returning strings to C# without leaking memory */ -typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -static char mimeTypeEmptyMsg[] = "Mime Type is Empty!"; -static char dataEmptyMsg[] = "Data is Empty!"; -static const char * nullExceptMsg = "Attempt to dereference null Dali::Adaptor::DragAndDrop"; - -using DnDCallback = void(SWIGSTDCALL *)(const Dali::DragAndDrop::DragEvent&); -DnDCallback dndCallback; - -using SourceCallback = void(SWIGSTDCALL *)(enum Dali::DragAndDrop::SourceEventType); -SourceCallback sourceCallback; - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_DragAndDrop_New__SWIG_0() { - void *jresult = nullptr; - Dali::DragAndDrop result; - try { - result = Dali::DragAndDrop::Get(); - jresult = new Dali::DragAndDrop((const Dali::DragAndDrop &)result); - - } CALL_CATCH_EXCEPTION(0); - - return jresult; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_DragAndDrop_StartDragAndDrop(void * argDnD, void * argSource, void * argShadowWindow, void * argMimeType, char * argData, void * argSourceCallback) { - Dali::DragAndDrop *dnd = (Dali::DragAndDrop *)argDnD; - - if (!dnd) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return false; - } - - Dali::Actor *pSource; - Dali::Window *pShadow; - Dali::Actor source; - Dali::Window shadow; - - pSource = (Dali::Actor *)argSource; - if (!pSource) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return false; - } - - pShadow = (Dali::Window *)argShadowWindow; - if (!pShadow) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return false; - } - - source = *pSource; - shadow = *pShadow; - - Dali::DragAndDrop::DragData dragData; - dragData.SetMimeType((const char*)argMimeType); - dragData.SetData(argData); - - bool result = false; - { - try { - sourceCallback = (SourceCallback)argSourceCallback; - result = dnd->StartDragAndDrop(source, shadow, dragData, sourceCallback); - } - CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_DragAndDrop_AddListener(void * jarg1, void * jarg2, void * jarg3) { - Dali::DragAndDrop *dnd = (Dali::DragAndDrop *)jarg1; - if (!dnd) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return false; - } - - Dali::Actor *argp2; - Dali::Actor target; - - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return false; - } - - target = *argp2; - bool result = false; - { - try { - dndCallback = (DnDCallback)jarg3; - result = dnd->AddListener(target, dndCallback); - } - CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_DragAndDrop_RemoveListener(void * argDnD, void * argTarget, void * argCallback) { - Dali::DragAndDrop *dnd = (Dali::DragAndDrop *)argDnD; - if (!dnd) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return false; - } - - Dali::Actor *pTarget; - Dali::Actor target; - - pTarget = (Dali::Actor *)argTarget; - if (!pTarget) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return false; - } - - target = *pTarget; - bool result = false; - { - try { - //TODO: use argCallback to remove target listener - result = dnd->RemoveListener(target); - } - CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DragEvent_GetAction(void * jarg) { - int jresult; - Dali::DragAndDrop::DragEvent *dragEvent = (Dali::DragAndDrop::DragEvent *)jarg; - - if (!dragEvent) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return 0; - } - { - try { - jresult = (int)((Dali::DragAndDrop::DragEvent &)*dragEvent).GetAction(); - } - CALL_CATCH_EXCEPTION(0); - } - - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragEvent_GetPosition(void * jarg) { - void * jresult = nullptr; - Dali::DragAndDrop::DragEvent *dragEvent = (Dali::DragAndDrop::DragEvent *)jarg; - Dali::Vector2 result; - - if (!dragEvent) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return 0; - } - { - try { - result = ((Dali::DragAndDrop::DragEvent &)*dragEvent).GetPosition(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragEvent_GetMimeType(void * argDragEvent) { - char * jresult = nullptr; - Dali::DragAndDrop::DragEvent *dragEvent = (Dali::DragAndDrop::DragEvent *)argDragEvent; - std::string result; - - if (!dragEvent) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return 0; - } - { - try { - const char* mimeType = ((Dali::DragAndDrop::DragEvent &)*dragEvent).GetMimeType(); - if (mimeType != nullptr) - { - result = mimeType; - } - else - { - result = mimeTypeEmptyMsg; - } - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback((&result)->c_str()); - return jresult; -} - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragEvent_GetData(void * argDragEvent) { - char * jresult = nullptr; - Dali::DragAndDrop::DragEvent *dragEvent = (Dali::DragAndDrop::DragEvent *)argDragEvent; - std::string result; - - if (!dragEvent) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return 0; - } - { - try { - const char* data = ((Dali::DragAndDrop::DragEvent &)*dragEvent).GetData(); - if (data != nullptr) - { - result = data; - } - else - { - result = dataEmptyMsg; - } - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback((&result)->c_str()); - return jresult; -} - -#ifdef __cplusplus -} // end extern "C" -#endif diff --git a/dali-csharp-binder/src/encoded-image-buffer-wrap.cpp b/dali-csharp-binder/src/encoded-image-buffer-wrap.cpp deleted file mode 100755 index 0c04cb75..00000000 --- a/dali-csharp-binder/src/encoded-image-buffer-wrap.cpp +++ /dev/null @@ -1,155 +0,0 @@ -/* - * Copyright (c) 2021 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_EncodedImageBuffer__SWIG_0() -{ - void *jresult; - Dali::EncodedImageBuffer *result = 0; - - { - try - { - result = new Dali::EncodedImageBuffer(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_EncodedImageBuffer__SWIG_1(void *nuiEncodedImageBuffer) -{ - void *jresult; - Dali::EncodedImageBuffer *result = (Dali::EncodedImageBuffer *)0; - Dali::EncodedImageBuffer *encodedImageBuffer = (Dali::EncodedImageBuffer *)nuiEncodedImageBuffer;; - - if (!encodedImageBuffer) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedImageBuffer const & type is null", 0); - return 0; - } - { - try - { - result = new Dali::EncodedImageBuffer((Dali::EncodedImageBuffer const &)*encodedImageBuffer); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -// note: nuiRawBuffer is same as Dali::Vector, which created by CSharp_Dali_new_VectorUnsignedChar__SWIG_0 -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_EncodedImageBuffer_New(void *nuiRawBuffer) -{ - void *jresult; - Dali::EncodedImageBuffer::RawBufferType *buffer = (Dali::EncodedImageBuffer::RawBufferType *)nuiRawBuffer; - Dali::EncodedImageBuffer result; - - if (!buffer) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0); - return 0; - } - { - try - { - result = Dali::EncodedImageBuffer::New((const Dali::EncodedImageBuffer::RawBufferType &)*buffer); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::EncodedImageBuffer((const Dali::EncodedImageBuffer &)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedImageBuffer(void *nuiEncodedImageBuffer) -{ - Dali::EncodedImageBuffer *encodedImageBuffer = (Dali::EncodedImageBuffer *)nuiEncodedImageBuffer;; - { - try - { - delete encodedImageBuffer; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_EncodedImageBuffer_GetRawBuffer(void *nuiEncodedImageBuffer) -{ - void *jresult; - Dali::EncodedImageBuffer::RawBufferType *result = (Dali::EncodedImageBuffer::RawBufferType *)0; - Dali::EncodedImageBuffer *encodedImageBuffer = (Dali::EncodedImageBuffer *)nuiEncodedImageBuffer;; - - if (!encodedImageBuffer) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedImageBuffer const & type is null", 0); - return 0; - } - { - try - { - result = const_cast(&(encodedImageBuffer->GetRawBuffer())); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_EncodedImageBuffer_GenerateUrl(void *nuiEncodedImageBuffer) -{ - void *jresult; - Dali::Toolkit::ImageUrl result; - Dali::EncodedImageBuffer *encodedImageBuffer = (Dali::EncodedImageBuffer *)nuiEncodedImageBuffer;; - - if (!encodedImageBuffer) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedImageBuffer const & type is null", 0); - return 0; - } - { - try - { - result = Dali::Toolkit::Image::GenerateUrl((const Dali::EncodedImageBuffer &)*encodedImageBuffer); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result); - return jresult; -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/event-thread-callback-wrap.cpp b/dali-csharp-binder/src/event-thread-callback-wrap.cpp deleted file mode 100755 index c7c98272..00000000 --- a/dali-csharp-binder/src/event-thread-callback-wrap.cpp +++ /dev/null @@ -1,100 +0,0 @@ -/* - * Copyright (c) 2017 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -typedef void (SWIGSTDCALL* SWIG_CallbackMakeCallback)(void); - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EventThreadCallback(SWIG_CallbackMakeCallback callbackOnMakeCallback) { - void * jresult ; - void (*arg1)(void) = (void (*)(void)) 0 ; - Dali::EventThreadCallback *result = 0 ; - Dali::CallbackBase * callbackBase = 0 ; - - arg1 = (void (*)(void))callbackOnMakeCallback; - callbackBase = (Dali::CallbackBase *)Dali::MakeCallback(arg1); - - { - try { - result = (Dali::EventThreadCallback *)new Dali::EventThreadCallback(callbackBase); - } catch (std::out_of_range& e) { - { - delete result; - delete callbackBase; - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); return 0; - }; - } catch (std::exception& e) { - { - delete result; - delete callbackBase; - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); return 0; - }; - } catch (Dali::DaliException e) { - { - delete result; - delete callbackBase; - SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; - }; - } catch (...) { - { - delete result; - delete callbackBase; - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; - }; - } - } - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EventThreadCallback(void * jarg1) { - Dali::EventThreadCallback *arg1 = (Dali::EventThreadCallback *) 0 ; - - arg1 = (Dali::EventThreadCallback *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_EventThreadCallback_Trigger(void * jarg1) { - Dali::EventThreadCallback *arg1 = (Dali::EventThreadCallback *) 0 ; - - arg1 = (Dali::EventThreadCallback *)jarg1; - { - try { - (arg1)->Trigger(); - } CALL_CATCH_EXCEPTION(); - } - -} - -#ifdef __cplusplus -} -#endif //CSHARP_EVENT_THREAD_CALLBACK - diff --git a/dali-csharp-binder/src/extents-wrap.cpp b/dali-csharp-binder/src/extents-wrap.cpp deleted file mode 100755 index 934887c0..00000000 --- a/dali-csharp-binder/src/extents-wrap.cpp +++ /dev/null @@ -1,269 +0,0 @@ -/* - * Copyright (c) 2021 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Extents__SWIG_0() { - void * jresult ; - Dali::Extents *result = 0 ; - - { - try { - result = (Dali::Extents *)new Dali::Extents(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Extents__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Extents *arg1 = 0 ; - Dali::Extents *result = 0 ; - - arg1 = (Dali::Extents *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Extents const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Extents *)new Dali::Extents((Dali::Extents const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Extents__SWIG_2(unsigned short jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4) { - void * jresult ; - uint16_t arg1 ; - uint16_t arg2 ; - uint16_t arg3 ; - uint16_t arg4 ; - Dali::Extents *result = 0 ; - - arg1 = (uint16_t)jarg1; - arg2 = (uint16_t)jarg2; - arg3 = (uint16_t)jarg3; - arg4 = (uint16_t)jarg4; - { - try { - result = (Dali::Extents *)new Dali::Extents(arg1, arg2, arg3, arg4); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Extents_Assign__SWIG_0(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Extents *arg1 = (Dali::Extents *) 0 ; - Dali::Extents *arg2 = 0 ; - Dali::Extents *result = 0 ; - - arg1 = (Dali::Extents *)jarg1; - arg2 = (Dali::Extents *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Extents const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Extents *) &(arg1)->operator =((Dali::Extents const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Extents_Assign__SWIG_1(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Extents *arg1 = (Dali::Extents *) 0 ; - uint16_t *arg2 = (uint16_t *) 0 ; - Dali::Extents *result = 0 ; - - arg1 = (Dali::Extents *)jarg1; - arg2 = (uint16_t *)jarg2; - { - try { - result = (Dali::Extents *) &(arg1)->operator =((uint16_t const *)arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Extents_EqualTo(void * jarg1, void * jarg2) { - unsigned int jresult ; - Dali::Extents *arg1 = (Dali::Extents *) 0 ; - Dali::Extents *arg2 = 0 ; - bool result; - - arg1 = (Dali::Extents *)jarg1; - arg2 = (Dali::Extents *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Extents const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Extents const *)arg1)->operator ==((Dali::Extents const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Extents_NotEqualTo(void * jarg1, void * jarg2) { - unsigned int jresult ; - Dali::Extents *arg1 = (Dali::Extents *) 0 ; - Dali::Extents *arg2 = 0 ; - bool result; - - arg1 = (Dali::Extents *)jarg1; - arg2 = (Dali::Extents *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Extents const & type is null", 0); - return 0; - } - { - try { - result = (bool)((Dali::Extents const *)arg1)->operator !=((Dali::Extents const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Extents_start_set(void * jarg1, unsigned short jarg2) { - Dali::Extents *arg1 = (Dali::Extents *) 0 ; - uint16_t arg2 ; - - arg1 = (Dali::Extents *)jarg1; - arg2 = (uint16_t)jarg2; - if (arg1) (arg1)->start = arg2; -} - - -SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Extents_start_get(void * jarg1) { - unsigned short jresult ; - Dali::Extents *arg1 = (Dali::Extents *) 0 ; - uint16_t result; - - arg1 = (Dali::Extents *)jarg1; - result = ((arg1)->start); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Extents_end_set(void * jarg1, unsigned short jarg2) { - Dali::Extents *arg1 = (Dali::Extents *) 0 ; - uint16_t arg2 ; - - arg1 = (Dali::Extents *)jarg1; - arg2 = (uint16_t)jarg2; - if (arg1) (arg1)->end = arg2; -} - - -SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Extents_end_get(void * jarg1) { - unsigned short jresult ; - Dali::Extents *arg1 = (Dali::Extents *) 0 ; - uint16_t result; - - arg1 = (Dali::Extents *)jarg1; - result = ((arg1)->end); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Extents_top_set(void * jarg1, unsigned short jarg2) { - Dali::Extents *arg1 = (Dali::Extents *) 0 ; - uint16_t arg2 ; - - arg1 = (Dali::Extents *)jarg1; - arg2 = (uint16_t)jarg2; - if (arg1) (arg1)->top = arg2; -} - - -SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Extents_top_get(void * jarg1) { - unsigned short jresult ; - Dali::Extents *arg1 = (Dali::Extents *) 0 ; - uint16_t result; - - arg1 = (Dali::Extents *)jarg1; - result = ((arg1)->top); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Extents_bottom_set(void * jarg1, unsigned short jarg2) { - Dali::Extents *arg1 = (Dali::Extents *) 0 ; - uint16_t arg2 ; - - arg1 = (Dali::Extents *)jarg1; - arg2 = (uint16_t)jarg2; - if (arg1) (arg1)->bottom = arg2; -} - - -SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Extents_bottom_get(void * jarg1) { - unsigned short jresult ; - Dali::Extents *arg1 = (Dali::Extents *) 0 ; - uint16_t result; - - arg1 = (Dali::Extents *)jarg1; - result = ((arg1)->bottom); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Extents(void * jarg1) { - Dali::Extents *arg1 = (Dali::Extents *) 0 ; - - arg1 = (Dali::Extents *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -#ifdef __cplusplus -} -#endif \ No newline at end of file diff --git a/dali-csharp-binder/src/fade-transition-wrap.cpp b/dali-csharp-binder/src/fade-transition-wrap.cpp deleted file mode 100755 index f2fa6e85..00000000 --- a/dali-csharp-binder/src/fade-transition-wrap.cpp +++ /dev/null @@ -1,131 +0,0 @@ -/* - * Copyright (c) 2021 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_FadeTransition() - { - void *jresult; - Dali::Toolkit::FadeTransition *result = 0; - - { - try - { - result = (Dali::Toolkit::FadeTransition *)new Dali::Toolkit::FadeTransition(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_FadeTransition_New(void *nuiControl, float nuiOpaicty, void *nuiTimePeriod) - { - void *jresult; - Dali::Toolkit::Control *control = (Dali::Toolkit::Control *)nuiControl; - float opacity = nuiOpaicty; - Dali::TimePeriod *timePeriod = (Dali::TimePeriod *)nuiTimePeriod; - - Dali::Toolkit::FadeTransition result; - - { - try - { - result = Dali::Toolkit::FadeTransition::New(*control, opacity, *timePeriod); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::FadeTransition((const Dali::Toolkit::FadeTransition &)result); - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FadeTransition(void *nuiFadeTransition) - { - Dali::Toolkit::FadeTransition *fade = (Dali::Toolkit::FadeTransition *)0; - - fade = (Dali::Toolkit::FadeTransition *)nuiFadeTransition; - { - try - { - delete fade; - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_FadeTransition_Set(void *nuiFadeTransition) - { - Dali::Toolkit::FadeTransition *newFadeTransition = 0; - Dali::Toolkit::FadeTransition *fade = (Dali::Toolkit::FadeTransition *)nuiFadeTransition; - if (!fade) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FadeTransition const & type is null", 0); - return 0; - } - { - try - { - newFadeTransition = (Dali::Toolkit::FadeTransition *)new Dali::Toolkit::FadeTransition((Dali::Toolkit::FadeTransition const &)*fade); - } - CALL_CATCH_EXCEPTION(0); - } - void *result; - result = (void *)newFadeTransition; - return result; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_FadeTransition_Assign(void *nuiDestination, void *nuiSource) - { - void *jresult; - Dali::Toolkit::FadeTransition *destination = (Dali::Toolkit::FadeTransition *)0; - Dali::Toolkit::FadeTransition *source = 0; - Dali::Toolkit::FadeTransition *result = 0; - - destination = (Dali::Toolkit::FadeTransition *)nuiDestination; - source = (Dali::Toolkit::FadeTransition *)nuiSource; - - if (!source) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FadeTransition const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Toolkit::FadeTransition *)&(destination)->operator=((Dali::Toolkit::FadeTransition const &)*source); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/flex-layout-wrap.cpp b/dali-csharp-binder/src/flex-layout-wrap.cpp deleted file mode 100755 index c5b2c3ea..00000000 --- a/dali-csharp-binder/src/flex-layout-wrap.cpp +++ /dev/null @@ -1,654 +0,0 @@ -/* - * Copyright (c) 2021 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexLayout_New() -{ - Dali::Toolkit::Flex::Node* result = (Dali::Toolkit::Flex::Node*)0; - { - try { - result = new Dali::Toolkit::Flex::Node(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); - }; - } - } - return (void *)result; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexLayout(void * jarg1) -{ - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - { - try { - delete arg1; - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); - }; - } - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexDirection(void * jarg1, int jarg2) -{ - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - Dali::Toolkit::Flex::FlexDirection arg2 ; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - arg2 = (Dali::Toolkit::Flex::FlexDirection)jarg2; - { - try { - arg1->Dali::Toolkit::Flex::Node::SetFlexDirection( arg2); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); - }; - } - } -} - -SWIGEXPORT const Dali::Toolkit::Flex::Node* SWIGSTDCALL CSharp_Dali_FlexLayout_AddChildWithMargin(void * jarg1, void *jarg2, void *jarg3, Dali::Toolkit::Flex::MeasureCallback jarg4, int jarg5) -{ - Dali::Toolkit::Flex::Node* arg1 = (Dali::Toolkit::Flex::Node* )jarg1; - Dali::Actor *arg2 = (Dali::Actor *) 0; arg2 = (Dali::Actor *)jarg2; - const Dali::Toolkit::Flex::Node* result = nullptr; - - { - try { - if(jarg3 == NULL) - { - result = arg1->Dali::Toolkit::Flex::Node::AddChild((Dali::Actor &)*arg2, Dali::Extents(0,0,0,0), jarg4, jarg5); - } - else - { - Dali::Extents* arg3 = (Dali::Extents *)jarg3; - result = arg1->Dali::Toolkit::Flex::Node::AddChild((Dali::Actor &)*arg2, *arg3, jarg4, jarg5); - } - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); - }; - } - } - return result; -} - -SWIGEXPORT const Dali::Toolkit::Flex::Node* SWIGSTDCALL CSharp_Dali_FlexLayout_AddChild(void * jarg1, void *jarg2, Dali::Toolkit::Flex::MeasureCallback jarg3, int jarg4) -{ - return CSharp_Dali_FlexLayout_AddChildWithMargin(jarg1,jarg2,NULL,jarg3,jarg4); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_RemoveChild(void * jarg1, void * jarg2) -{ - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - Dali::Actor* arg2 = (Dali::Actor *)jarg2; - - arg1 = (Dali::Toolkit::Flex::Node*)jarg1; - { - try { - arg1->Dali::Toolkit::Flex::Node::RemoveChild(*arg2); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); - }; - } - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_CalculateLayout(void * jarg1, float jarg2, float jarg3, bool isRtl ) -{ - Dali::Toolkit::Flex::Node * arg1 = (Dali::Toolkit::Flex::Node* )jarg1; - { - try { - arg1->Dali::Toolkit::Flex::Node::CalculateLayout(jarg2, jarg3, isRtl); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); - }; - } - } -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetWidth(void * jarg1 ) -{ - Dali::Toolkit::Flex::Node* arg1 = (Dali::Toolkit::Flex::Node* )jarg1 ; - float result = 0.0f; - { - try { - result = arg1->Dali::Toolkit::Flex::Node::GetFlexWidth(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); - }; - } - } - return result; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetHeight(void * jarg1 ) -{ - float result = 0.0f; - Dali::Toolkit::Flex::Node* arg1 = (Dali::Toolkit::Flex::Node* )jarg1 ; - { - try { - result = arg1->Dali::Toolkit::Flex::Node::GetFlexHeight(); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); - }; - } - } - return result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_FlexLayout_GetNodeFrame( void * jarg1, int index ) -{ - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - Dali::Vector4 result; - void* jresult; - { - try { - result = arg1->Dali::Toolkit::Flex::Node::GetNodeFrame(index); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); - }; - } - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetMargin(void * jarg1, void * jarg2) -{ - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - Dali::Extents* arg2 = (Dali::Extents *)jarg2; - { - try { - arg1->Dali::Toolkit::Flex::Node::SetMargin( *arg2); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); - }; - } - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetPadding(void * jarg1, void * jarg2) -{ - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - Dali::Extents* arg2 = (Dali::Extents *)jarg2; - { - try { - arg1->Dali::Toolkit::Flex::Node::SetPadding( *arg2); - } catch (std::out_of_range& e) { - { - SWIG_CSharpException(SWIG_IndexError, const_cast(e.what())); - }; - } catch (std::exception& e) { - { - SWIG_CSharpException(SWIG_RuntimeError, const_cast(e.what())); - }; - } catch (...) { - { - SWIG_CSharpException(SWIG_UnknownError, "unknown error"); - }; - } - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexDirection(void * jarg1) -{ - int jresult ; - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - Dali::Toolkit::Flex::FlexDirection result; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - { - try { - result = (Dali::Toolkit::Flex::FlexDirection)arg1->Dali::Toolkit::Flex::Node::GetFlexDirection(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexJustification(void * jarg1, int jarg2) -{ - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - Dali::Toolkit::Flex::Justification arg2 ; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - arg2 = (Dali::Toolkit::Flex::Justification)jarg2; - { - try { - arg1->Dali::Toolkit::Flex::Node::SetFlexJustification(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexJustification(void * jarg1) -{ - int jresult ; - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - Dali::Toolkit::Flex::Justification result; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - { - try { - result = (Dali::Toolkit::Flex::Justification)arg1->Dali::Toolkit::Flex::Node::GetFlexJustification(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexWrap(void * jarg1, int jarg2) -{ - - Dali::Toolkit::Flex::Node* arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - Dali::Toolkit::Flex::WrapType arg2 = (Dali::Toolkit::Flex::WrapType)jarg2; - { - try { - arg1->Dali::Toolkit::Flex::Node::SetFlexWrap(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexWrap(void * jarg1) -{ - int jresult ; - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - Dali::Toolkit::Flex::WrapType result; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - { - try { - result = (Dali::Toolkit::Flex::WrapType)arg1->Dali::Toolkit::Flex::Node::GetFlexWrap(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexAlignment(void * jarg1, int jarg2) -{ - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - Dali::Toolkit::Flex::Alignment arg2 ; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - arg2 = (Dali::Toolkit::Flex::Alignment)jarg2; - { - try { - arg1->Dali::Toolkit::Flex::Node::SetFlexAlignment(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexAlignment(void * jarg1) -{ - int jresult ; - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - Dali::Toolkit::Flex::Alignment result; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - { - try { - result = (Dali::Toolkit::Flex::Alignment)arg1->Dali::Toolkit::Flex::Node::GetFlexAlignment(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexItemsAlignment(void * jarg1, int jarg2) -{ - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - Dali::Toolkit::Flex::Alignment arg2 ; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - arg2 = (Dali::Toolkit::Flex::Alignment)jarg2; - { - try { - arg1->Dali::Toolkit::Flex::Node::SetFlexItemsAlignment(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexItemsAlignment(void * jarg1) -{ - int jresult ; - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - Dali::Toolkit::Flex::Alignment result; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - { - try { - result = (Dali::Toolkit::Flex::Alignment)arg1->Dali::Toolkit::Flex::Node::GetFlexItemsAlignment(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexAlignmentSelf(void * jarg1, int jarg2) -{ - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - Dali::Toolkit::Flex::Alignment arg2 ; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - arg2 = (Dali::Toolkit::Flex::Alignment)jarg2; - { - try { - arg1->Dali::Toolkit::Flex::Node::SetFlexAlignmentSelf(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexAlignmentSelf(void * jarg1) -{ - int jresult ; - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - Dali::Toolkit::Flex::Alignment result; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - { - try { - result = (Dali::Toolkit::Flex::Alignment)arg1->Dali::Toolkit::Flex::Node::GetFlexAlignmentSelf(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexPositionType(void * jarg1, int jarg2) -{ - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - Dali::Toolkit::Flex::PositionType arg2 ; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - arg2 = (Dali::Toolkit::Flex::PositionType)jarg2; - { - try { - arg1->Dali::Toolkit::Flex::Node::SetFlexPositionType(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexPositionType(void * jarg1) -{ - int jresult ; - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - Dali::Toolkit::Flex::PositionType result; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - { - try { - result = (Dali::Toolkit::Flex::PositionType)arg1->Dali::Toolkit::Flex::Node::GetFlexPositionType(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexAspectRatio(void * jarg1, float jarg2) -{ - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - arg2 = (float)jarg2; - { - try { - arg1->Dali::Toolkit::Flex::Node::SetFlexAspectRatio(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexAspectRatio(void * jarg1) -{ - int jresult ; - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - float result; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - { - try { - result = (float)arg1->Dali::Toolkit::Flex::Node::GetFlexAspectRatio(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (float)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexBasis(void * jarg1, float jarg2) -{ - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - arg2 = (float)jarg2; - { - try { - arg1->Dali::Toolkit::Flex::Node::SetFlexBasis(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexBasis(void * jarg1) -{ - int jresult ; - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - float result; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - { - try { - result = (float)arg1->Dali::Toolkit::Flex::Node::GetFlexBasis(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (float)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexShrink(void * jarg1, float jarg2) -{ - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - arg2 = (float)jarg2; - { - try { - arg1->Dali::Toolkit::Flex::Node::SetFlexShrink(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexShrink(void * jarg1) -{ - int jresult ; - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - float result; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - { - try { - result = (float)arg1->Dali::Toolkit::Flex::Node::GetFlexShrink(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (float)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexGrow(void * jarg1, float jarg2) -{ - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - arg2 = (float)jarg2; - { - try { - arg1->Dali::Toolkit::Flex::Node::SetFlexGrow(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexGrow(void * jarg1) -{ - int jresult ; - Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ; - float result; - - arg1 = (Dali::Toolkit::Flex::Node *)jarg1; - { - try { - result = (float)arg1->Dali::Toolkit::Flex::Node::GetFlexGrow(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (float)result; - return jresult; -} - - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/font-client-wrap.cpp b/dali-csharp-binder/src/font-client-wrap.cpp deleted file mode 100755 index 152a2e98..00000000 --- a/dali-csharp-binder/src/font-client-wrap.cpp +++ /dev/null @@ -1,1859 +0,0 @@ -/* - * Copyright (c) 2017 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include -#include -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -/* Callback for returning strings to C# without leaking memory */ -typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - - -typedef std::string FontPath; -typedef std::string FontFamily; -typedef std::string FontStyle; -typedef std::vector FontPathList; -typedef std::vector FontFamilyList; -typedef std::vector FontList; - -typedef uint32_t FontId; -typedef uint32_t PointSize26Dot6; -typedef uint32_t FaceIndex; -typedef uint32_t GlyphIndex; -typedef uint32_t Character; -typedef uint32_t CharacterIndex; -typedef uint32_t Length; -typedef uint32_t BidiInfoIndex; -typedef char LineBreakInfo; -typedef char WordBreakInfo; -typedef bool CharacterDirection; - - -#ifdef __cplusplus -extern "C" { -#endif - - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FontClient_SWIGUpcast(Dali::TextAbstraction::FontClient *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_PreCache(char ** fallbackFamilyArray, int fallbackFamilySize, char ** extraFamilyArray, int extraFamilySize, char * localeFamilyString, bool useThread, bool syncCreation) { - FontFamilyList fallbackFamilyList; - FontFamilyList extraFamilyList; - FontFamily localeFamily = localeFamilyString ? localeFamilyString : ""; - - if(fallbackFamilyArray) - { - fallbackFamilyList.assign(fallbackFamilyArray, fallbackFamilyArray + fallbackFamilySize); - } - - if(extraFamilyArray) - { - extraFamilyList.assign(extraFamilyArray, extraFamilyArray + extraFamilySize); - } - - Dali::TextAbstraction::FontClientPreCache(fallbackFamilyList, extraFamilyList, localeFamily, useThread, syncCreation); -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_FontPreLoad(char ** fontPathArray, int fontPathSize, char ** memoryFontPathArray, int memoryFontPathSize, bool useThread, bool syncCreation) { - FontPathList fontPathList; - FontPathList memoryFontPathList; - - if(fontPathArray) - { - fontPathList.assign(fontPathArray, fontPathArray + fontPathSize); - } - - if(memoryFontPathArray) - { - memoryFontPathList.assign(memoryFontPathArray, memoryFontPathArray + memoryFontPathSize); - } - - Dali::TextAbstraction::FontClientFontPreLoad(fontPathList, memoryFontPathList, useThread, syncCreation); -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontWidthName_get() { - void * jresult ; - char **result = 0 ; - - result = (char **)(char **)Dali::TextAbstraction::FontWidth::Name; - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontWeightName_get() { - void * jresult ; - char **result = 0 ; - - result = (char **)(char **)Dali::TextAbstraction::FontWeight::Name; - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontSlantName_get() { - void * jresult ; - char **result = 0 ; - - result = (char **)(char **)Dali::TextAbstraction::FontSlant::Name; - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FontDescription() { - void * jresult ; - Dali::TextAbstraction::FontDescription *result = 0 ; - - { - try { - result = (Dali::TextAbstraction::FontDescription *)new Dali::TextAbstraction::FontDescription(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FontDescription(void * jarg1) { - Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; - - arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontDescription_path_set(void * jarg1, char * jarg2) { - Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; - Dali::TextAbstraction::FontPath *arg2 = 0 ; - - arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - Dali::TextAbstraction::FontPath arg2_str(jarg2); - arg2 = &arg2_str; - if (arg1) (arg1)->path = *arg2; -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_FontDescription_path_get(void * jarg1) { - char * jresult ; - Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; - Dali::TextAbstraction::FontPath *result = 0 ; - - arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; - result = (Dali::TextAbstraction::FontPath *) & ((arg1)->path); - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontDescription_family_set(void * jarg1, char * jarg2) { - Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; - Dali::TextAbstraction::FontFamily *arg2 = 0 ; - - arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - Dali::TextAbstraction::FontFamily arg2_str(jarg2); - arg2 = &arg2_str; - if (arg1) (arg1)->family = *arg2; -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_FontDescription_family_get(void * jarg1) { - char * jresult ; - Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; - Dali::TextAbstraction::FontFamily *result = 0 ; - - arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; - result = (Dali::TextAbstraction::FontFamily *) & ((arg1)->family); - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontDescription_width_set(void * jarg1, int jarg2) { - Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; - Dali::TextAbstraction::FontWidth::Type arg2 ; - - arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; - arg2 = (Dali::TextAbstraction::FontWidth::Type)jarg2; - if (arg1) (arg1)->width = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontDescription_width_get(void * jarg1) { - int jresult ; - Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; - Dali::TextAbstraction::FontWidth::Type result; - - arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; - result = (Dali::TextAbstraction::FontWidth::Type) ((arg1)->width); - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontDescription_weight_set(void * jarg1, int jarg2) { - Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; - Dali::TextAbstraction::FontWeight::Type arg2 ; - - arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; - arg2 = (Dali::TextAbstraction::FontWeight::Type)jarg2; - if (arg1) (arg1)->weight = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontDescription_weight_get(void * jarg1) { - int jresult ; - Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; - Dali::TextAbstraction::FontWeight::Type result; - - arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; - result = (Dali::TextAbstraction::FontWeight::Type) ((arg1)->weight); - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontDescription_slant_set(void * jarg1, int jarg2) { - Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; - Dali::TextAbstraction::FontSlant::Type arg2 ; - - arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; - arg2 = (Dali::TextAbstraction::FontSlant::Type)jarg2; - if (arg1) (arg1)->slant = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontDescription_slant_get(void * jarg1) { - int jresult ; - Dali::TextAbstraction::FontDescription *arg1 = (Dali::TextAbstraction::FontDescription *) 0 ; - Dali::TextAbstraction::FontSlant::Type result; - - arg1 = (Dali::TextAbstraction::FontDescription *)jarg1; - result = (Dali::TextAbstraction::FontSlant::Type) ((arg1)->slant); - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FontMetrics__SWIG_0() { - void * jresult ; - Dali::TextAbstraction::FontMetrics *result = 0 ; - - { - try { - result = (Dali::TextAbstraction::FontMetrics *)new Dali::TextAbstraction::FontMetrics(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FontMetrics__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5) { - void * jresult ; - float arg1 ; - float arg2 ; - float arg3 ; - float arg4 ; - float arg5 ; - Dali::TextAbstraction::FontMetrics *result = 0 ; - - arg1 = (float)jarg1; - arg2 = (float)jarg2; - arg3 = (float)jarg3; - arg4 = (float)jarg4; - arg5 = (float)jarg5; - { - try { - result = (Dali::TextAbstraction::FontMetrics *)new Dali::TextAbstraction::FontMetrics(arg1,arg2,arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontMetrics_ascender_set(void * jarg1, float jarg2) { - Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; - float arg2 ; - - arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->ascender = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FontMetrics_ascender_get(void * jarg1) { - float jresult ; - Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; - float result; - - arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; - result = (float) ((arg1)->ascender); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontMetrics_descender_set(void * jarg1, float jarg2) { - Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; - float arg2 ; - - arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->descender = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FontMetrics_descender_get(void * jarg1) { - float jresult ; - Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; - float result; - - arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; - result = (float) ((arg1)->descender); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontMetrics_height_set(void * jarg1, float jarg2) { - Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; - float arg2 ; - - arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->height = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FontMetrics_height_get(void * jarg1) { - float jresult ; - Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; - float result; - - arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; - result = (float) ((arg1)->height); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontMetrics_underlinePosition_set(void * jarg1, float jarg2) { - Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; - float arg2 ; - - arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->underlinePosition = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FontMetrics_underlinePosition_get(void * jarg1) { - float jresult ; - Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; - float result; - - arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; - result = (float) ((arg1)->underlinePosition); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontMetrics_underlineThickness_set(void * jarg1, float jarg2) { - Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; - float arg2 ; - - arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->underlineThickness = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FontMetrics_underlineThickness_get(void * jarg1) { - float jresult ; - Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; - float result; - - arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; - result = (float) ((arg1)->underlineThickness); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FontMetrics(void * jarg1) { - Dali::TextAbstraction::FontMetrics *arg1 = (Dali::TextAbstraction::FontMetrics *) 0 ; - - arg1 = (Dali::TextAbstraction::FontMetrics *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LINE_MUST_BREAK_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::TextAbstraction::LINE_MUST_BREAK; - } CALL_CATCH_EXCEPTION(0); - } - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LINE_ALLOW_BREAK_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::TextAbstraction::LINE_ALLOW_BREAK; - } CALL_CATCH_EXCEPTION(0); - } - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LINE_NO_BREAK_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::TextAbstraction::LINE_NO_BREAK; - } CALL_CATCH_EXCEPTION(0); - } - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WORD_BREAK_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::TextAbstraction::WORD_BREAK; - } CALL_CATCH_EXCEPTION(0); - } - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WORD_NO_BREAK_get() { - int jresult ; - int result; - - { - try { - result = (int)Dali::TextAbstraction::WORD_NO_BREAK; - } CALL_CATCH_EXCEPTION(0); - } - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBlob_r_set(void * jarg1, unsigned char jarg2) { - Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ; - unsigned char arg2 ; - - arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1; - arg2 = (unsigned char)jarg2; - if (arg1) (arg1)->r = arg2; -} - - -SWIGEXPORT unsigned char SWIGSTDCALL CSharp_Dali_VectorBlob_r_get(void * jarg1) { - unsigned char jresult ; - Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ; - unsigned char result; - - arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1; - result = (unsigned char) ((arg1)->r); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBlob_g_set(void * jarg1, unsigned char jarg2) { - Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ; - unsigned char arg2 ; - - arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1; - arg2 = (unsigned char)jarg2; - if (arg1) (arg1)->g = arg2; -} - - -SWIGEXPORT unsigned char SWIGSTDCALL CSharp_Dali_VectorBlob_g_get(void * jarg1) { - unsigned char jresult ; - Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ; - unsigned char result; - - arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1; - result = (unsigned char) ((arg1)->g); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBlob_b_set(void * jarg1, unsigned char jarg2) { - Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ; - unsigned char arg2 ; - - arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1; - arg2 = (unsigned char)jarg2; - if (arg1) (arg1)->b = arg2; -} - - -SWIGEXPORT unsigned char SWIGSTDCALL CSharp_Dali_VectorBlob_b_get(void * jarg1) { - unsigned char jresult ; - Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ; - unsigned char result; - - arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1; - result = (unsigned char) ((arg1)->b); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBlob_a_set(void * jarg1, unsigned char jarg2) { - Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ; - unsigned char arg2 ; - - arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1; - arg2 = (unsigned char)jarg2; - if (arg1) (arg1)->a = arg2; -} - - -SWIGEXPORT unsigned char SWIGSTDCALL CSharp_Dali_VectorBlob_a_get(void * jarg1) { - unsigned char jresult ; - Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ; - unsigned char result; - - arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1; - result = (unsigned char) ((arg1)->a); - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorBlob() { - void * jresult ; - Dali::TextAbstraction::VectorBlob *result = 0 ; - - { - try { - result = (Dali::TextAbstraction::VectorBlob *)new Dali::TextAbstraction::VectorBlob(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorBlob(void * jarg1) { - Dali::TextAbstraction::VectorBlob *arg1 = (Dali::TextAbstraction::VectorBlob *) 0 ; - - arg1 = (Dali::TextAbstraction::VectorBlob *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GlyphInfo__SWIG_0() { - void * jresult ; - Dali::TextAbstraction::GlyphInfo *result = 0 ; - - { - try { - result = (Dali::TextAbstraction::GlyphInfo *)new Dali::TextAbstraction::GlyphInfo(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GlyphInfo__SWIG_1(unsigned int jarg1, unsigned int jarg2) { - void * jresult ; - Dali::TextAbstraction::FontId arg1 ; - Dali::TextAbstraction::GlyphIndex arg2 ; - Dali::TextAbstraction::GlyphInfo *result = 0 ; - - arg1 = (Dali::TextAbstraction::FontId)jarg1; - arg2 = (Dali::TextAbstraction::GlyphIndex)jarg2; - { - try { - result = (Dali::TextAbstraction::GlyphInfo *)new Dali::TextAbstraction::GlyphInfo(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_fontId_set(void * jarg1, unsigned int jarg2) { - Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; - Dali::TextAbstraction::FontId arg2 ; - - arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; - arg2 = (Dali::TextAbstraction::FontId)jarg2; - if (arg1) (arg1)->fontId = arg2; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlyphInfo_fontId_get(void * jarg1) { - unsigned int jresult ; - Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; - Dali::TextAbstraction::FontId result; - - arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; - result = ((arg1)->fontId); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_index_set(void * jarg1, unsigned int jarg2) { - Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; - Dali::TextAbstraction::GlyphIndex arg2 ; - - arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; - arg2 = (Dali::TextAbstraction::GlyphIndex)jarg2; - if (arg1) (arg1)->index = arg2; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlyphInfo_index_get(void * jarg1) { - unsigned int jresult ; - Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; - Dali::TextAbstraction::GlyphIndex result; - - arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; - result = ((arg1)->index); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_width_set(void * jarg1, float jarg2) { - Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; - float arg2 ; - - arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->width = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GlyphInfo_width_get(void * jarg1) { - float jresult ; - Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; - float result; - - arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; - result = (float) ((arg1)->width); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_height_set(void * jarg1, float jarg2) { - Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; - float arg2 ; - - arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->height = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GlyphInfo_height_get(void * jarg1) { - float jresult ; - Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; - float result; - - arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; - result = (float) ((arg1)->height); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_xBearing_set(void * jarg1, float jarg2) { - Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; - float arg2 ; - - arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->xBearing = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GlyphInfo_xBearing_get(void * jarg1) { - float jresult ; - Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; - float result; - - arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; - result = (float) ((arg1)->xBearing); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_yBearing_set(void * jarg1, float jarg2) { - Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; - float arg2 ; - - arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->yBearing = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GlyphInfo_yBearing_get(void * jarg1) { - float jresult ; - Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; - float result; - - arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; - result = (float) ((arg1)->yBearing); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_advance_set(void * jarg1, float jarg2) { - Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; - float arg2 ; - - arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->advance = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GlyphInfo_advance_get(void * jarg1) { - float jresult ; - Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; - float result; - - arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; - result = (float) ((arg1)->advance); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlyphInfo_scaleFactor_set(void * jarg1, float jarg2) { - Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; - float arg2 ; - - arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->scaleFactor = arg2; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GlyphInfo_scaleFactor_get(void * jarg1) { - float jresult ; - Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; - float result; - - arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; - result = (float) ((arg1)->scaleFactor); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GlyphInfo(void * jarg1) { - Dali::TextAbstraction::GlyphInfo *arg1 = (Dali::TextAbstraction::GlyphInfo *) 0 ; - - arg1 = (Dali::TextAbstraction::GlyphInfo *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_DEFAULT_POINT_SIZE_get() { - unsigned int jresult ; - Dali::TextAbstraction::PointSize26Dot6 result; - - result = (Dali::TextAbstraction::PointSize26Dot6)Dali::TextAbstraction::FontClient::DEFAULT_POINT_SIZE; - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FontClient_GlyphBufferData() { - void * jresult ; - Dali::TextAbstraction::GlyphBufferData *result = 0 ; - - { - try { - result = (Dali::TextAbstraction::GlyphBufferData *)new Dali::TextAbstraction::GlyphBufferData(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FontClient_GlyphBufferData(void * jarg1) { - Dali::TextAbstraction::GlyphBufferData *arg1 = (Dali::TextAbstraction::GlyphBufferData *) 0 ; - - arg1 = (Dali::TextAbstraction::GlyphBufferData *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -/* -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_buffer_set(void * jarg1, unsigned char* jarg2) { - Dali::TextAbstraction::GlyphBufferData *arg1 = (Dali::TextAbstraction::GlyphBufferData *) 0 ; - unsigned char *arg2 = (unsigned char *) 0 ; - - arg1 = (Dali::TextAbstraction::GlyphBufferData *)jarg1; - arg2 = jarg2; - if (arg1) (arg1)->buffer = arg2; - - -} - - -SWIGEXPORT unsigned char* SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_buffer_get(void * jarg1) { - unsigned char* jresult ; - Dali::TextAbstraction::GlyphBufferData *arg1 = (Dali::TextAbstraction::GlyphBufferData *) 0 ; - unsigned char *result = 0 ; - - arg1 = (Dali::TextAbstraction::GlyphBufferData *)jarg1; - result = (unsigned char *) ((arg1)->buffer); - jresult = (void *)result; - return jresult; -} -*/ - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_width_set(void * jarg1, unsigned int jarg2) { - Dali::TextAbstraction::GlyphBufferData *arg1 = (Dali::TextAbstraction::GlyphBufferData *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::TextAbstraction::GlyphBufferData *)jarg1; - arg2 = (unsigned int)jarg2; - if (arg1) (arg1)->width = arg2; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_width_get(void * jarg1) { - unsigned int jresult ; - Dali::TextAbstraction::GlyphBufferData *arg1 = (Dali::TextAbstraction::GlyphBufferData *) 0 ; - unsigned int result; - - arg1 = (Dali::TextAbstraction::GlyphBufferData *)jarg1; - result = (unsigned int) ((arg1)->width); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_height_set(void * jarg1, unsigned int jarg2) { - Dali::TextAbstraction::GlyphBufferData *arg1 = (Dali::TextAbstraction::GlyphBufferData *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::TextAbstraction::GlyphBufferData *)jarg1; - arg2 = (unsigned int)jarg2; - if (arg1) (arg1)->height = arg2; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_height_get(void * jarg1) { - unsigned int jresult ; - Dali::TextAbstraction::GlyphBufferData *arg1 = (Dali::TextAbstraction::GlyphBufferData *) 0 ; - unsigned int result; - - arg1 = (Dali::TextAbstraction::GlyphBufferData *)jarg1; - result = (unsigned int) ((arg1)->height); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_format_set(void * jarg1, int jarg2) { - Dali::TextAbstraction::GlyphBufferData *arg1 = (Dali::TextAbstraction::GlyphBufferData *) 0 ; - Dali::Pixel::Format arg2 ; - - arg1 = (Dali::TextAbstraction::GlyphBufferData *)jarg1; - arg2 = (Dali::Pixel::Format)jarg2; - if (arg1) (arg1)->format = arg2; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontClient_GlyphBufferData_format_get(void * jarg1) { - int jresult ; - Dali::TextAbstraction::GlyphBufferData *arg1 = (Dali::TextAbstraction::GlyphBufferData *) 0 ; - Dali::Pixel::Format result; - - arg1 = (Dali::TextAbstraction::GlyphBufferData *)jarg1; - result = (Dali::Pixel::Format) ((arg1)->format); - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontClient_Get() { - void * jresult ; - Dali::TextAbstraction::FontClient result; - - { - try { - result = Dali::TextAbstraction::FontClient::Get(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::TextAbstraction::FontClient((const Dali::TextAbstraction::FontClient &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FontClient__SWIG_0() { - void * jresult ; - Dali::TextAbstraction::FontClient *result = 0 ; - - { - try { - result = (Dali::TextAbstraction::FontClient *)new Dali::TextAbstraction::FontClient(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FontClient(void * jarg1) { - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FontClient__SWIG_1(void * jarg1) { - void * jresult ; - Dali::TextAbstraction::FontClient *arg1 = 0 ; - Dali::TextAbstraction::FontClient *result = 0 ; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontClient const & type is null", 0); - return 0; - } - { - try { - result = (Dali::TextAbstraction::FontClient *)new Dali::TextAbstraction::FontClient((Dali::TextAbstraction::FontClient const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontClient_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontClient *arg2 = 0 ; - Dali::TextAbstraction::FontClient *result = 0 ; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::FontClient *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontClient const & type is null", 0); - return 0; - } - { - try { - result = (Dali::TextAbstraction::FontClient *) &(arg1)->operator =((Dali::TextAbstraction::FontClient const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_SetDpi(void * jarg1, unsigned int jarg2, unsigned int jarg3) { - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - unsigned int arg2 ; - unsigned int arg3 ; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (unsigned int)jarg2; - arg3 = (unsigned int)jarg3; - { - try { - (arg1)->SetDpi(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetDpi(void * jarg1, void * jarg2, void * jarg3) { - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - unsigned int *arg2 = 0 ; - unsigned int *arg3 = 0 ; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (unsigned int *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "unsigned int & type is null", 0); - return ; - } - arg3 = (unsigned int *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "unsigned int & type is null", 0); - return ; - } - { - try { - (arg1)->GetDpi(*arg2,*arg3); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontClient_GetDefaultFontSize(void * jarg1) { - int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - int result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - { - try { - result = (int)(arg1)->GetDefaultFontSize(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_ResetSystemDefaults(void * jarg1) { - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - { - try { - (arg1)->ResetSystemDefaults(); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetDefaultFonts(void * jarg1, void * jarg2) { - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontList *arg2 = 0 ; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::FontList *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontList & type is null", 0); - return ; - } - { - try { - (arg1)->GetDefaultFonts(*arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetDefaultPlatformFontDescription(void * jarg1, void * jarg2) { - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontDescription *arg2 = 0 ; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::FontDescription *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription & type is null", 0); - return ; - } - { - try { - (arg1)->GetDefaultPlatformFontDescription(*arg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontClient_GetSystemFonts(void* fontClient) { - void* jresult; - Dali::Property::Array *array = 0; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0; - - arg1 = (Dali::TextAbstraction::FontClient *)fontClient; - { - try { - FontList fontList; - (arg1)->GetSystemFonts(fontList); - - Dali::Property::Array systemFonts; - for(size_t i = 0; i < fontList.size(); i++) - { - Dali::Property::Map font; - font.Add("family", fontList[i].family); - font.Add("path", fontList[i].path); - font.Add("width", fontList[i].width); - font.Add("weight", fontList[i].weight); - font.Add("slant", fontList[i].slant); - systemFonts.PushBack(font); - } - - array = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)systemFonts); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)array; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetDescription(void * jarg1, unsigned int jarg2, void * jarg3) { - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontId arg2 ; - Dali::TextAbstraction::FontDescription *arg3 = 0 ; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::FontId)jarg2; - arg3 = (Dali::TextAbstraction::FontDescription *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription & type is null", 0); - return ; - } - { - try { - (arg1)->GetDescription(arg2,*arg3); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetPointSize(void * jarg1, unsigned int jarg2) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontId arg2 ; - Dali::TextAbstraction::PointSize26Dot6 result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::FontId)jarg2; - { - try { - result = (arg1)->GetPointSize(arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_IsCharacterSupportedByFont(void * jarg1, unsigned int jarg2, unsigned int jarg3) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontId arg2 ; - Dali::TextAbstraction::Character arg3 ; - bool result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::FontId)jarg2; - arg3 = (Dali::TextAbstraction::Character)jarg3; - { - try { - result = (bool)(arg1)->IsCharacterSupportedByFont(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_FindDefaultFont__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::Character arg2 ; - Dali::TextAbstraction::PointSize26Dot6 arg3 ; - bool arg4 ; - Dali::TextAbstraction::FontId result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::Character)jarg2; - arg3 = (Dali::TextAbstraction::PointSize26Dot6)jarg3; - arg4 = jarg4 ? true : false; - { - try { - result = (arg1)->FindDefaultFont(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_FindDefaultFont__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::Character arg2 ; - Dali::TextAbstraction::PointSize26Dot6 arg3 ; - Dali::TextAbstraction::FontId result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::Character)jarg2; - arg3 = (Dali::TextAbstraction::PointSize26Dot6)jarg3; - { - try { - result = (arg1)->FindDefaultFont(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_FindDefaultFont__SWIG_2(void * jarg1, unsigned int jarg2) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::Character arg2 ; - Dali::TextAbstraction::FontId result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::Character)jarg2; - { - try { - result = (arg1)->FindDefaultFont(arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_FindFallbackFont__SWIG_0(void * jarg1, unsigned int jarg2, void * jarg3, unsigned int jarg4, unsigned int jarg5) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::Character arg2 ; - Dali::TextAbstraction::FontDescription *arg3 = 0 ; - Dali::TextAbstraction::PointSize26Dot6 arg4 ; - bool arg5 ; - Dali::TextAbstraction::FontId result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::Character)jarg2; - arg3 = (Dali::TextAbstraction::FontDescription *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0); - return 0; - } - arg4 = (Dali::TextAbstraction::PointSize26Dot6)jarg4; - arg5 = jarg5 ? true : false; - { - try { - result = (arg1)->FindFallbackFont(arg2,(Dali::TextAbstraction::FontDescription const &)*arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_FindFallbackFont__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3, unsigned int jarg4) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::Character arg2 ; - Dali::TextAbstraction::FontDescription *arg3 = 0 ; - Dali::TextAbstraction::PointSize26Dot6 arg4 ; - Dali::TextAbstraction::FontId result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::Character)jarg2; - arg3 = (Dali::TextAbstraction::FontDescription *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0); - return 0; - } - arg4 = (Dali::TextAbstraction::PointSize26Dot6)jarg4; - { - try { - result = (arg1)->FindFallbackFont(arg2,(Dali::TextAbstraction::FontDescription const &)*arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_FindFallbackFont__SWIG_2(void * jarg1, unsigned int jarg2, void * jarg3) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::Character arg2 ; - Dali::TextAbstraction::FontDescription *arg3 = 0 ; - Dali::TextAbstraction::FontId result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::Character)jarg2; - arg3 = (Dali::TextAbstraction::FontDescription *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0); - return 0; - } - { - try { - result = (arg1)->FindFallbackFont(arg2,(Dali::TextAbstraction::FontDescription const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetFontId__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontPath *arg2 = 0 ; - Dali::TextAbstraction::PointSize26Dot6 arg3 ; - Dali::TextAbstraction::FaceIndex arg4 ; - Dali::TextAbstraction::FontId result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - Dali::TextAbstraction::FontPath arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::TextAbstraction::PointSize26Dot6)jarg3; - arg4 = (Dali::TextAbstraction::FaceIndex)jarg4; - { - try { - result = (arg1)->GetFontId((Dali::TextAbstraction::FontPath const &)*arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetFontId__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontPath *arg2 = 0 ; - Dali::TextAbstraction::PointSize26Dot6 arg3 ; - Dali::TextAbstraction::FontId result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - Dali::TextAbstraction::FontPath arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::TextAbstraction::PointSize26Dot6)jarg3; - { - try { - result = (arg1)->GetFontId((Dali::TextAbstraction::FontPath const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetFontId__SWIG_2(void * jarg1, char * jarg2) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontPath *arg2 = 0 ; - Dali::TextAbstraction::FontId result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - Dali::TextAbstraction::FontPath arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - result = (arg1)->GetFontId((Dali::TextAbstraction::FontPath const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetFontId__SWIG_3(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontDescription *arg2 = 0 ; - Dali::TextAbstraction::PointSize26Dot6 arg3 ; - Dali::TextAbstraction::FaceIndex arg4 ; - Dali::TextAbstraction::FontId result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::FontDescription *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0); - return 0; - } - arg3 = (Dali::TextAbstraction::PointSize26Dot6)jarg3; - arg4 = (Dali::TextAbstraction::FaceIndex)jarg4; - { - try { - result = (arg1)->GetFontId((Dali::TextAbstraction::FontDescription const &)*arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetFontId__SWIG_4(void * jarg1, void * jarg2, unsigned int jarg3) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontDescription *arg2 = 0 ; - Dali::TextAbstraction::PointSize26Dot6 arg3 ; - Dali::TextAbstraction::FontId result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::FontDescription *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0); - return 0; - } - arg3 = (Dali::TextAbstraction::PointSize26Dot6)jarg3; - { - try { - result = (arg1)->GetFontId((Dali::TextAbstraction::FontDescription const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetFontId__SWIG_5(void * jarg1, void * jarg2) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontDescription *arg2 = 0 ; - Dali::TextAbstraction::FontId result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::FontDescription *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0); - return 0; - } - { - try { - result = (arg1)->GetFontId((Dali::TextAbstraction::FontDescription const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_IsScalable__SWIG_0(void * jarg1, char * jarg2) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontPath *arg2 = 0 ; - bool result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - Dali::TextAbstraction::FontPath arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - result = (bool)(arg1)->IsScalable((Dali::TextAbstraction::FontPath const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_IsScalable__SWIG_1(void * jarg1, void * jarg2) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontDescription *arg2 = 0 ; - bool result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::FontDescription *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0); - return 0; - } - { - try { - result = (bool)(arg1)->IsScalable((Dali::TextAbstraction::FontDescription const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetFixedSizes__SWIG_0(void * jarg1, char * jarg2, void * jarg3) { - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontPath *arg2 = 0 ; - Dali::Vector< Dali::TextAbstraction::PointSize26Dot6,Dali::TypeTraits< Dali::TextAbstraction::PointSize26Dot6 >::IS_TRIVIAL_TYPE==true > *arg3 = 0 ; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - Dali::TextAbstraction::FontPath arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (Dali::Vector< Dali::TextAbstraction::PointSize26Dot6,Dali::TypeTraits< Dali::TextAbstraction::PointSize26Dot6 >::IS_TRIVIAL_TYPE==true > *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::TextAbstraction::PointSize26Dot6,Dali::TypeTraits< Dali::TextAbstraction::PointSize26Dot6 >::IS_TRIVIAL_TYPE==true > & type is null", 0); - return ; - } - { - try { - (arg1)->GetFixedSizes((Dali::TextAbstraction::FontPath const &)*arg2,*arg3); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetFixedSizes__SWIG_1(void * jarg1, void * jarg2, void * jarg3) { - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontDescription *arg2 = 0 ; - Dali::Vector< Dali::TextAbstraction::PointSize26Dot6,Dali::TypeTraits< Dali::TextAbstraction::PointSize26Dot6 >::IS_TRIVIAL_TYPE==true > *arg3 = 0 ; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::FontDescription *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontDescription const & type is null", 0); - return ; - } - arg3 = (Dali::Vector< Dali::TextAbstraction::PointSize26Dot6,Dali::TypeTraits< Dali::TextAbstraction::PointSize26Dot6 >::IS_TRIVIAL_TYPE==true > *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::TextAbstraction::PointSize26Dot6,Dali::TypeTraits< Dali::TextAbstraction::PointSize26Dot6 >::IS_TRIVIAL_TYPE==true > & type is null", 0); - return ; - } - { - try { - (arg1)->GetFixedSizes((Dali::TextAbstraction::FontDescription const &)*arg2,*arg3); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_GetFontMetrics(void * jarg1, unsigned int jarg2, void * jarg3) { - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontId arg2 ; - Dali::TextAbstraction::FontMetrics *arg3 = 0 ; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::FontId)jarg2; - arg3 = (Dali::TextAbstraction::FontMetrics *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::FontMetrics & type is null", 0); - return ; - } - { - try { - (arg1)->GetFontMetrics(arg2,*arg3); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetGlyphIndex(void * jarg1, unsigned int jarg2, unsigned int jarg3) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontId arg2 ; - Dali::TextAbstraction::Character arg3 ; - Dali::TextAbstraction::GlyphIndex result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::FontId)jarg2; - arg3 = (Dali::TextAbstraction::Character)jarg3; - { - try { - result = (arg1)->GetGlyphIndex(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetGlyphMetrics__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::GlyphInfo *arg2 = (Dali::TextAbstraction::GlyphInfo *) 0 ; - uint32_t arg3 ; - Dali::TextAbstraction::GlyphType arg4 ; - bool arg5 ; - bool result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::GlyphInfo *)jarg2; - arg3 = (uint32_t)jarg3; - arg4 = (Dali::TextAbstraction::GlyphType)jarg4; - arg5 = jarg5 ? true : false; - { - try { - result = (bool)(arg1)->GetGlyphMetrics(arg2,arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_GetGlyphMetrics__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::GlyphInfo *arg2 = (Dali::TextAbstraction::GlyphInfo *) 0 ; - uint32_t arg3 ; - Dali::TextAbstraction::GlyphType arg4 ; - bool result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::GlyphInfo *)jarg2; - arg3 = (uint32_t)jarg3; - arg4 = (Dali::TextAbstraction::GlyphType)jarg4; - { - try { - result = (bool)(arg1)->GetGlyphMetrics(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_CreateBitmap__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3, bool jarg4, bool jarg5, void * jarg6, int jarg7) { - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontId arg2 ; - Dali::TextAbstraction::GlyphIndex arg3 ; - bool arg4; - bool arg5; - Dali::TextAbstraction::GlyphBufferData *arg6 = 0 ; - int arg7 ; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::FontId)jarg2; - arg3 = (Dali::TextAbstraction::GlyphIndex)jarg3; - arg4 = jarg4; - arg5 = jarg5; - arg6 = (Dali::TextAbstraction::GlyphBufferData *)jarg6; - if (!arg6) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::GlyphBufferData & type is null", 0); - return ; - } - arg7 = (int)jarg7; - { - try { - (arg1)->CreateBitmap(arg2,arg3,arg4,arg5,*arg6,arg7); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontClient_CreateBitmap__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) { - void * jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontId arg2 ; - Dali::TextAbstraction::GlyphIndex arg3 ; - int arg4 ; - Dali::PixelData result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::FontId)jarg2; - arg3 = (Dali::TextAbstraction::GlyphIndex)jarg3; - arg4 = (int)jarg4; - { - try { - result = (arg1)->CreateBitmap(arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::PixelData((const Dali::PixelData &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FontClient_CreateVectorBlob(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) { - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontId arg2 ; - Dali::TextAbstraction::GlyphIndex arg3 ; - Dali::TextAbstraction::VectorBlob **arg4 = 0 ; - unsigned int *arg5 = 0 ; - unsigned int *arg6 = 0 ; - unsigned int *arg7 = 0 ; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::FontId)jarg2; - arg3 = (Dali::TextAbstraction::GlyphIndex)jarg3; - arg4 = (Dali::TextAbstraction::VectorBlob **)jarg4; - if (!arg4) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextAbstraction::VectorBlob *& type is null", 0); - return ; - } - arg5 = (unsigned int *)jarg5; - if (!arg5) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "unsigned int & type is null", 0); - return ; - } - arg6 = (unsigned int *)jarg6; - if (!arg6) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "unsigned int & type is null", 0); - return ; - } - arg7 = (unsigned int *)jarg7; - if (!arg7) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "unsigned int & type is null", 0); - return ; - } - { - try { - (arg1)->CreateVectorBlob(arg2,arg3,*arg4,*arg5,*arg6,*arg7); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FontClient_GetEllipsisGlyph(void * jarg1, unsigned int jarg2) { - void * jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::PointSize26Dot6 arg2 ; - Dali::TextAbstraction::GlyphInfo *result = 0 ; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::PointSize26Dot6)jarg2; - { - try { - result = (Dali::TextAbstraction::GlyphInfo *) &(arg1)->GetEllipsisGlyph(arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_IsColorGlyph(void * jarg1, unsigned int jarg2, unsigned int jarg3) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontId arg2 ; - Dali::TextAbstraction::GlyphIndex arg3 ; - bool result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - arg2 = (Dali::TextAbstraction::FontId)jarg2; - arg3 = (Dali::TextAbstraction::GlyphIndex)jarg3; - { - try { - result = (bool)(arg1)->IsColorGlyph(arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FontClient_AddCustomFontDirectory(void * jarg1, char * jarg2) { - unsigned int jresult ; - Dali::TextAbstraction::FontClient *arg1 = (Dali::TextAbstraction::FontClient *) 0 ; - Dali::TextAbstraction::FontPath *arg2 = 0 ; - bool result; - - arg1 = (Dali::TextAbstraction::FontClient *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - Dali::TextAbstraction::FontPath arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - result = (bool)(arg1)->AddCustomFontDirectory((Dali::TextAbstraction::FontPath const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/gestures-wrap.cpp b/dali-csharp-binder/src/gestures-wrap.cpp deleted file mode 100755 index cc9418e5..00000000 --- a/dali-csharp-binder/src/gestures-wrap.cpp +++ /dev/null @@ -1,442 +0,0 @@ -/* - * Copyright (c) 2020 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -using namespace Dali; - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > const *self) -{ - return self->Empty(); -} - -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > const *self) -{ - return self->GetConnectionCount(); -} - -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *self,void (*func)(Dali::Actor,Dali::RotationGesture const &)) -{ - self->Connect( func ); -} - -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *self,void (*func)(Dali::Actor,Dali::RotationGesture const &)) -{ - self->Disconnect( func ); -} - -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *self,Dali::Actor arg1,Dali::RotationGesture const &arg2) -{ - self->Emit( arg1, arg2 ); -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RotationGestureDetector__SWIG_0() -{ - void * jresult ; - Dali::RotationGestureDetector *result = 0 ; - - { - try { - result = (Dali::RotationGestureDetector *)new Dali::RotationGestureDetector(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGestureDetector_New() { - void * jresult ; - Dali::RotationGestureDetector result; - - { - try { - result = Dali::RotationGestureDetector::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::RotationGestureDetector((const Dali::RotationGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGestureDetector_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::RotationGestureDetector 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::RotationGestureDetector::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::RotationGestureDetector((const Dali::RotationGestureDetector &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RotationGestureDetector(void * jarg1) { - Dali::RotationGestureDetector *arg1 = (Dali::RotationGestureDetector *) 0 ; - - arg1 = (Dali::RotationGestureDetector *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RotationGestureDetector__SWIG_1(void * jarg1) { - void * jresult ; - Dali::RotationGestureDetector *arg1 = 0 ; - Dali::RotationGestureDetector *result = 0 ; - - arg1 = (Dali::RotationGestureDetector *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RotationGestureDetector const & type is null", 0); - return 0; - } - { - try { - result = (Dali::RotationGestureDetector *)new Dali::RotationGestureDetector((Dali::RotationGestureDetector const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGestureDetector_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::RotationGestureDetector *arg1 = (Dali::RotationGestureDetector *) 0 ; - Dali::RotationGestureDetector *arg2 = 0 ; - Dali::RotationGestureDetector *result = 0 ; - - arg1 = (Dali::RotationGestureDetector *)jarg1; - arg2 = (Dali::RotationGestureDetector *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RotationGestureDetector const & type is null", 0); - return 0; - } - { - try { - result = (Dali::RotationGestureDetector *) &(arg1)->operator =((Dali::RotationGestureDetector const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGestureDetector_DetectedSignal(void * jarg1) { - void * jresult ; - Dali::RotationGestureDetector *arg1 = (Dali::RotationGestureDetector *) 0 ; - Dali::RotationGestureDetector::DetectedSignalType *result = 0 ; - - arg1 = (Dali::RotationGestureDetector *)jarg1; - { - try { - result = (Dali::RotationGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RotationGesture__SWIG_0() { - void * jresult ; - Dali::RotationGesture *result = 0 ; - - { - try { - result = (Dali::RotationGesture *)new Dali::RotationGesture(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGesture_New(int jarg1) { - void * jresult ; - Dali::GestureState arg1 ; - Dali::RotationGesture result; - - arg1 = (Dali::GestureState)jarg1; - { - try { - result = DevelRotationGesture::New(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::RotationGesture((const Dali::RotationGesture &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RotationGesture__SWIG_1(void * jarg1) { - void * jresult ; - Dali::RotationGesture *arg1 = 0 ; - Dali::RotationGesture *result = 0 ; - - arg1 = (Dali::RotationGesture *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RotationGesture const & type is null", 0); - return 0; - } - { - try { - result = (Dali::RotationGesture *)new Dali::RotationGesture((Dali::RotationGesture const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGesture_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::RotationGesture *arg1 = (Dali::RotationGesture *) 0 ; - Dali::RotationGesture *arg2 = 0 ; - Dali::RotationGesture *result = 0 ; - - arg1 = (Dali::RotationGesture *)jarg1; - arg2 = (Dali::RotationGesture *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RotationGesture const & type is null", 0); - return 0; - } - { - try { - result = (Dali::RotationGesture *) &(arg1)->operator =((Dali::RotationGesture const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RotationGesture(void * jarg1) { - Dali::RotationGesture *arg1 = (Dali::RotationGesture *) 0 ; - - arg1 = (Dali::RotationGesture *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RotationGesture_rotation_get(void * jarg1) { - float jresult ; - Dali::RotationGesture *arg1 = (Dali::RotationGesture *) 0 ; - float result; - - arg1 = (Dali::RotationGesture *)jarg1; - result = (float) ((arg1)->GetRotation().radian); - jresult = result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGesture_screenCenterPoint_get(void * jarg1) { - void * jresult ; - Dali::RotationGesture *arg1 = (Dali::RotationGesture *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::RotationGesture *)jarg1; - { - try { - result = ((Dali::RotationGesture const *)arg1)->GetScreenCenterPoint(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RotationGesture_localCenterPoint_get(void * jarg1) { - void * jresult ; - Dali::RotationGesture *arg1 = (Dali::RotationGesture *) 0 ; - Dali::Vector2 result; - - arg1 = (Dali::RotationGesture *)jarg1; - { - try { - result = ((Dali::RotationGesture const *)arg1)->GetLocalCenterPoint(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RotationGestureDetectedSignal_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_RotationGestureDetectedSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RotationGestureDetectedSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *) 0 ; - void (*arg2)(Dali::Actor,Dali::RotationGesture const &) = (void (*)(Dali::Actor,Dali::RotationGesture const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)jarg1; - arg2 = (void (*)(Dali::Actor,Dali::RotationGesture const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RotationGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *) 0 ; - void (*arg2)(Dali::Actor,Dali::RotationGesture const &) = (void (*)(Dali::Actor,Dali::RotationGesture const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)jarg1; - arg2 = (void (*)(Dali::Actor,Dali::RotationGesture const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RotationGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) { - Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *) 0 ; - Dali::Actor arg2 ; - Dali::RotationGesture *arg3 = 0 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - arg3 = (Dali::RotationGesture *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RotationGesture const & type is null", 0); - return ; - } - { - try { - Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_RotationGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::RotationGesture const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RotationGestureDetectedSignal() { - void * jresult ; - Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RotationGestureDetectedSignal(void * jarg1) { - Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Actor,Dali::RotationGesture const &) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_RotationGestureDetector_SWIGUpcast(Dali::RotationGestureDetector *jarg1) { - return (Dali::GestureDetector *)jarg1; -} - -SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_RotationGesture_SWIGUpcast(Dali::RotationGesture *jarg1) { - return (Dali::Gesture *)jarg1; -} - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/gl-view-wrap.cpp b/dali-csharp-binder/src/gl-view-wrap.cpp deleted file mode 100644 index 4cfdcd27..00000000 --- a/dali-csharp-binder/src/gl-view-wrap.cpp +++ /dev/null @@ -1,378 +0,0 @@ -/* - * Copyright (c) 2021 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" -#include - -#ifdef __cplusplus -extern "C" -{ -#endif - - /*GlView binding*/ - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlView_New_SWIG(int nuiColorFormat) - { - void *jresult; - Dali::Toolkit::GlView result; - - Dali::Toolkit::GlView::ColorFormat colorFormat; - colorFormat = static_cast(nuiColorFormat); - { - try - { - result = Dali::Toolkit::GlView::New(colorFormat); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::GlView((const Dali::Toolkit::GlView &)result); - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlView_New2_SWIG(int nuiBackendMode, int nuiColorFormat) - { - void *jresult; - Dali::Toolkit::GlView result; - - Dali::Toolkit::GlView::ColorFormat colorFormat; - Dali::Toolkit::GlView::BackendMode backendMode; - colorFormat = static_cast(nuiColorFormat); - backendMode = static_cast(nuiBackendMode); - { - try - { - - result = Dali::Toolkit::GlView::New(backendMode, colorFormat); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::GlView((const Dali::Toolkit::GlView &)result); - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlView_SWIG_0() - { - void *jresult; - Dali::Toolkit::GlView *result = nullptr; - - { - try - { - result = (Dali::Toolkit::GlView *)new Dali::Toolkit::GlView(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlView_SWIG_1(void *nuiGlView) - { - void *jresult; - Dali::Toolkit::GlView *glView = nullptr; - Dali::Toolkit::GlView *result = nullptr; - - glView = (Dali::Toolkit::GlView *)nuiGlView; - if (!glView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GlView const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Toolkit::GlView *)new Dali::Toolkit::GlView((Dali::Toolkit::GlView const &)*glView); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GlView(void *nuiGlView) - { - Dali::Toolkit::GlView *glView = nullptr; - - glView = (Dali::Toolkit::GlView *)nuiGlView; - { - try - { - delete glView; - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlView_Assign(void *nuiGlView1, void *nuiGlView2) - { - void *jresult; - Dali::Toolkit::GlView *glView1 = nullptr; - Dali::Toolkit::GlView *glView2 = nullptr; - Dali::Toolkit::GlView *result = nullptr; - - glView1 = (Dali::Toolkit::GlView *)nuiGlView1; - glView2 = (Dali::Toolkit::GlView *)nuiGlView2; - if (!glView2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GlView const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Toolkit::GlView *)&(glView1)->operator=((Dali::Toolkit::GlView const &)*glView2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlView_SetGraphicsConfig(void *nuiGlView, bool nuiDepth, bool nuiStencil, int nuiMsaa, int nuiVersion) - { - Dali::Toolkit::GlView *glView = nullptr; - Dali::Toolkit::GlView::GraphicsApiVersion version; - - glView = (Dali::Toolkit::GlView *)nuiGlView; - version = static_cast(nuiVersion); - { - try - { - (glView)->SetGraphicsConfig(nuiDepth, nuiStencil, nuiMsaa, version); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlView_RegisterGlCallbacks(void *nuiGlView, void *nuiInitCB, int *nuiRenderFrameCB, void *nuiTerminateCB) - { - Dali::Toolkit::GlView *glView = (Dali::Toolkit::GlView *)nuiGlView; - void (*initCB)() = (void (*)())nuiInitCB; - int (*renderFrameCB)() = (int (*)())nuiRenderFrameCB; - void (*terminateCB)() = (void (*)())nuiTerminateCB; - - if (!glView || !initCB || !renderFrameCB || !terminateCB) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null", 0); - return; - } - try - { - glView->RegisterGlCallbacks(Dali::MakeCallback(initCB), Dali::MakeCallback(renderFrameCB), Dali::MakeCallback(terminateCB)); - } - CALL_CATCH_EXCEPTION(); - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlView_SetResizeCallback(void *nuiGlView, void *nuiResizeCB) - { - Dali::Toolkit::GlView *glView = (Dali::Toolkit::GlView *)nuiGlView; - void (*resizeCB)(int, int) = (void (*)(int, int))nuiResizeCB; - - if (!glView || !resizeCB) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null", 0); - return; - } - try - { - glView->SetResizeCallback(Dali::MakeCallback(resizeCB)); - } - CALL_CATCH_EXCEPTION(); - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlView_RenderOnce(void *nuiGlView) - { - Dali::Toolkit::GlView *glView = (Dali::Toolkit::GlView *)nuiGlView; - if (!glView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GlView", 0); - return; - } - { - try - { - glView->RenderOnce(); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlView_BindTextureResources(void *nuiGlView, void *textures, int size) - { - Dali::Toolkit::GlView *glView = (Dali::Toolkit::GlView *)nuiGlView; - Dali::Texture **texPtr = (Dali::Texture **)textures; - if (!glView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GlView", 0); - return; - } - { - try - { - // Convert array to vector - std::vector vTex; - for (int i = 0; i < size; i++) - { - Dali::Texture texture = *texPtr[i]; - vTex.push_back(texture); - } - glView->BindTextureResources(vTex); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GlView_GetRenderingMode(void *nuiGlView) - { - int jresult; - Dali::Toolkit::GlView *glView = nullptr; - Dali::Toolkit::GlView::RenderingMode result; - - glView = (Dali::Toolkit::GlView *)nuiGlView; - if (!glView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GlView", 0); - return 0; - } - - { - try - { - result = (Dali::Toolkit::GlView::RenderingMode)(glView)->GetRenderingMode(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlView_SetRenderingMode(void *nuiGlView, int nuiRenderingMode) - { - Dali::Toolkit::GlView *glView = nullptr; - Dali::Toolkit::GlView::RenderingMode renderingMode; - - glView = (Dali::Toolkit::GlView *)nuiGlView; - if (!glView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GlView", 0); - return; - } - renderingMode = (Dali::Toolkit::GlView::RenderingMode)nuiRenderingMode; - { - try - { - (glView)->SetRenderingMode(renderingMode); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GlView_GetBackendMode(void *nuiGlView) - { - int jresult; - Dali::Toolkit::GlView *glView = nullptr; - Dali::Toolkit::GlView::BackendMode result; - - glView = (Dali::Toolkit::GlView *)nuiGlView; - if (!glView) - { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::Toolkit::GlView", 0); - return 0; - } - - { - try - { - result = (Dali::Toolkit::GlView::BackendMode)(glView)->GetBackendMode(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_RenderCallbackInput_Size_get(void *input) - { - void *jresult; - Dali::Size *result = 0; - Dali::RenderCallbackInput *renderInput = (Dali::RenderCallbackInput *)input; - - result = &(renderInput->size); - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_RenderCallbackInput_Mvp_get(void *input) - { - void *jresult; - Dali::Matrix *result = 0; - Dali::RenderCallbackInput *renderInput = (Dali::RenderCallbackInput *)input; - - result = &(renderInput->mvp); - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_RenderCallbackInput_Projection_get(void *input) - { - void *jresult; - Dali::Matrix *result = 0; - Dali::RenderCallbackInput *renderInput = (Dali::RenderCallbackInput *)input; - - result = &(renderInput->projection); - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_RenderCallbackInput_ClippingBox_get(void *input) - { - void *jresult; - Dali::Rect *result = 0; - Dali::RenderCallbackInput *renderInput = (Dali::RenderCallbackInput *)input; - - result = &(renderInput->clippingBox); - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_RenderCallbackInput_TextureBindings_get(void *input, int *size) - { - void *jresult; - uint *result = 0; - Dali::RenderCallbackInput *renderInput = (Dali::RenderCallbackInput *)input; - - result = renderInput->textureBindings.data(); - *size = renderInput->textureBindings.size(); - jresult = (void *)result; - return jresult; - } - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/gl-window-wrap.cpp b/dali-csharp-binder/src/gl-window-wrap.cpp deleted file mode 100644 index adeb5b18..00000000 --- a/dali-csharp-binder/src/gl-window-wrap.cpp +++ /dev/null @@ -1,1295 +0,0 @@ -/* - * Copyright (c) 2020 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -/* Callback for returning strings to C# without leaking memory */ -typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -/* TODO Adding signal definition */ -SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal const *self) -{ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal const *self) -{ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal *self, void (*func)(Dali::GlWindow, bool)) -{ - self->Connect(func); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal *self, void (*func)(Dali::GlWindow, bool)) -{ - self->Disconnect(func); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal *self, Dali::GlWindow arg, bool focusIn) -{ - self->Emit(arg, focusIn); -} - -/*ResizeSignal*/ -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Empty(Dali::Signal const *self) -{ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__GetConnectionCount(Dali::Signal const *self) -{ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Connect(Dali::Signal *self, void (*func)(Dali::GlWindow::WindowSize)) -{ - self->Connect(func); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Disconnect(Dali::Signal *self, void (*func)(Dali::GlWindow::WindowSize)) -{ - self->Disconnect(func); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Emit(Dali::Signal *self, Dali::GlWindow::WindowSize arg) -{ - self->Emit(arg); -} - -#ifdef __cplusplus -extern "C" -{ -#endif - - /*Window binding*/ - SWIGEXPORT Dali::BaseHandle *SWIGSTDCALL CSharp_Dali_GlWindow_SWIGUpcast(Dali::GlWindow *jarg1) - { - return (Dali::BaseHandle *)jarg1; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_New__SWIG_0() - { - void *jresult; - Dali::GlWindow result; - { - try - { - - result = Dali::GlWindow::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::GlWindow((const Dali::GlWindow &)result); - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_New__SWIG_1(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::GlWindow 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::GlWindow::New(arg1, (std::string const &)*arg2, (std::string const &)*arg3, arg4); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::GlWindow((const Dali::GlWindow &)result); - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlWindow__SWIG_0() - { - void *jresult; - Dali::GlWindow *result = 0; - - { - try - { - result = (Dali::GlWindow *)new Dali::GlWindow(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GlWindow(void *jarg1) - { - Dali::GlWindow *arg1 = (Dali::GlWindow *)0; - - arg1 = (Dali::GlWindow *)jarg1; - { - try - { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlWindow__SWIG_1(void *jarg1) - { - void *jresult; - Dali::GlWindow *arg1 = 0; - Dali::GlWindow *result = 0; - - arg1 = (Dali::GlWindow *)jarg1; - if (!arg1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GlWindow const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::GlWindow *)new Dali::GlWindow((Dali::GlWindow const &)*arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_Assign(void *jarg1, void *jarg2) - { - void *jresult; - Dali::GlWindow *arg1 = (Dali::GlWindow *)0; - Dali::GlWindow *arg2 = 0; - Dali::GlWindow *result = 0; - - arg1 = (Dali::GlWindow *)jarg1; - arg2 = (Dali::GlWindow *)jarg2; - if (!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GlWindow const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::GlWindow *)&(arg1)->operator=((Dali::GlWindow const &)*arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetGraphicsConfig(void *jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, int jarg5) - { - Dali::GlWindow *arg1 = (Dali::GlWindow *)0; - bool arg2; - bool arg3; - int arg4; - Dali::GlWindow::GlesVersion arg5; - - arg1 = (Dali::GlWindow *)jarg1; - arg2 = (bool)jarg2; - arg3 = (bool)jarg3; - arg4 = jarg4; - arg5 = static_cast(jarg5); - { - try - { - (arg1)->SetGraphicsConfig(arg2, arg3, arg4, arg5); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Raise(void *jarg1) - { - Dali::GlWindow *arg1 = (Dali::GlWindow *)0; - - arg1 = (Dali::GlWindow *)jarg1; - { - try - { - (arg1)->Raise(); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Lower(void *jarg1) - { - Dali::GlWindow *arg1 = (Dali::GlWindow *)0; - - arg1 = (Dali::GlWindow *)jarg1; - { - try - { - (arg1)->Lower(); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Activate(void *jarg1) - { - Dali::GlWindow *arg1 = (Dali::GlWindow *)0; - - arg1 = (Dali::GlWindow *)jarg1; - { - try - { - (arg1)->Activate(); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Show(void *jarg1) - { - Dali::GlWindow arg1; - Dali::GlWindow *argp1; - - argp1 = (Dali::GlWindow *)jarg1; - if (!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return; - } - arg1 = *argp1; - { - try - { - arg1.Show(); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Hide(void *jarg1) - { - Dali::GlWindow arg1; - Dali::GlWindow *argp1; - - argp1 = (Dali::GlWindow *)jarg1; - if (!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return; - } - arg1 = *argp1; - { - try - { - arg1.Hide(); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetPositionSize(void *jarg1, void *jarg2) - { - Dali::GlWindow arg1; - Dali::GlWindow *argp1 = (Dali::GlWindow *)jarg1; - if (!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return; - } - arg1 = *argp1; - Dali::Rect *positionSize = (Dali::Rect *)jarg2; - if (!positionSize) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); - return; - } - { - try - { - arg1.SetPositionSize(*positionSize); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_GetPositionSize(void *jarg1) - { - void *jresult; - Dali::GlWindow arg1; - Dali::GlWindow *argp1; - Dali::PositionSize result; - - argp1 = (Dali::GlWindow *)jarg1; - if (!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return 0; - } - arg1 = *argp1; - { - try - { - result = arg1.GetPositionSize(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::PositionSize((const Dali::PositionSize &)result); - return jresult; - } - - SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_GetSupportedAuxiliaryHintCount(void *jarg1) - { - unsigned int jresult; - Dali::GlWindow arg1; - Dali::GlWindow *argp1; - unsigned int result; - - argp1 = (Dali::GlWindow *)jarg1; - if (!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return 0; - } - arg1 = *argp1; - { - try - { - result = (unsigned int)arg1.GetSupportedAuxiliaryHintCount(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; - } - - SWIGEXPORT char *SWIGSTDCALL CSharp_Dali_GlWindow_GetSupportedAuxiliaryHint(void *jarg1, unsigned int jarg2) - { - char *jresult; - Dali::GlWindow arg1; - unsigned int arg2; - Dali::GlWindow *argp1; - std::string result; - - argp1 = (Dali::GlWindow *)jarg1; - if (!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return 0; - } - arg1 = *argp1; - arg2 = (unsigned int)jarg2; - { - try - { - result = arg1.GetSupportedAuxiliaryHint(arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback((&result)->c_str()); - return jresult; - } - - SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_AddAuxiliaryHint(void *jarg1, char *jarg2, char *jarg3) - { - unsigned int jresult; - Dali::GlWindow arg1; - std::string *arg2 = 0; - std::string *arg3 = 0; - Dali::GlWindow *argp1; - unsigned int result; - - argp1 = (Dali::GlWindow *)jarg1; - if (!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 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; - { - try - { - result = (unsigned int)arg1.AddAuxiliaryHint((std::string const &)*arg2, (std::string const &)*arg3); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - return jresult; - } - - SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_RemoveAuxiliaryHint(void *jarg1, unsigned int jarg2) - { - unsigned int jresult; - Dali::GlWindow arg1; - unsigned int arg2; - Dali::GlWindow *argp1; - bool result; - - argp1 = (Dali::GlWindow *)jarg1; - if (!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return 0; - } - arg1 = *argp1; - arg2 = (unsigned int)jarg2; - { - try - { - result = (bool)arg1.RemoveAuxiliaryHint(arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; - } - - SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_SetAuxiliaryHintValue(void *jarg1, unsigned int jarg2, char *jarg3) - { - unsigned int jresult; - Dali::GlWindow arg1; - unsigned int arg2; - std::string *arg3 = 0; - Dali::GlWindow *argp1; - bool result; - - argp1 = (Dali::GlWindow *)jarg1; - if (!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return 0; - } - arg1 = *argp1; - arg2 = (unsigned int)jarg2; - if (!jarg3) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg3_str(jarg3); - arg3 = &arg3_str; - { - try - { - result = (bool)arg1.SetAuxiliaryHintValue(arg2, (std::string const &)*arg3); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - return jresult; - } - - SWIGEXPORT char *SWIGSTDCALL CSharp_Dali_GlWindow_GetAuxiliaryHintValue(void *jarg1, unsigned int jarg2) - { - char *jresult; - Dali::GlWindow arg1; - unsigned int arg2; - Dali::GlWindow *argp1; - std::string result; - - argp1 = (Dali::GlWindow *)jarg1; - if (!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return 0; - } - arg1 = *argp1; - arg2 = (unsigned int)jarg2; - { - try - { - result = arg1.GetAuxiliaryHintValue(arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback((&result)->c_str()); - return jresult; - } - - SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_GetAuxiliaryHintId(void *jarg1, char *jarg2) - { - unsigned int jresult; - Dali::GlWindow arg1; - std::string *arg2 = 0; - Dali::GlWindow *argp1; - unsigned int result; - - argp1 = (Dali::GlWindow *)jarg1; - if (!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return 0; - } - arg1 = *argp1; - if (!jarg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try - { - result = (unsigned int)arg1.GetAuxiliaryHintId((std::string const &)*arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetInputRegion(void *jarg1, void *jarg2) - { - Dali::GlWindow arg1; - Dali::Rect *arg2 = 0; - Dali::GlWindow *argp1; - - argp1 = (Dali::GlWindow *)jarg1; - if (!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return; - } - arg1 = *argp1; - arg2 = (Dali::Rect *)jarg2; - if (!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); - return; - } - { - try - { - arg1.SetInputRegion((Dali::Rect const &)*arg2); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetOpaqueState(void *jarg1, unsigned int jarg2) - { - Dali::GlWindow arg1; - bool arg2; - Dali::GlWindow *argp1; - - argp1 = (Dali::GlWindow *)jarg1; - if (!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return; - } - arg1 = *argp1; - arg2 = jarg2 ? true : false; - { - try - { - arg1.SetOpaqueState(arg2); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_IsOpaqueState(void *jarg1) - { - unsigned int jresult; - Dali::GlWindow arg1; - Dali::GlWindow *argp1; - bool result; - - argp1 = (Dali::GlWindow *)jarg1; - if (!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return 0; - } - arg1 = *argp1; - { - try - { - result = (bool)arg1.IsOpaqueState(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GlWindow_GetCurrentOrientation(void *jarg1) - { - int jresult; - Dali::WindowOrientation result; - Dali::GlWindow *arg1 = (Dali::GlWindow *)0; - arg1 = (Dali::GlWindow *)jarg1; - if (!arg1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return 0; - } - { - try - { - result = (arg1)->GetCurrentOrientation(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetAvailableOrientations(void *jarg1, void *jarg2, int jarg3) - { - Dali::GlWindow *arg1 = (Dali::GlWindow *)jarg1; - if (!arg1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return; - } - Dali::Property::Array *arg2 = (static_cast(jarg2)); - unsigned int count = static_cast(jarg3); - - Dali::Vector angles; - angles.Resize(count); - for (Dali::Property::Array::SizeType i = 0; i < count; ++i) - { - int angle = arg2->GetElementAt(i).Get(); - angles[i] = static_cast(angle); - } - { - try - { - arg1->SetAvailableOrientations(angles); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetPreferredOrientation(void *jarg1, int jarg2) - { - Dali::GlWindow *arg1 = (Dali::GlWindow *)0; - Dali::WindowOrientation arg2; - int angle = jarg2; - - arg1 = (Dali::GlWindow *)jarg1; - arg2 = (Dali::WindowOrientation)angle; - { - try - { - (arg1)->SetPreferredOrientation(arg2); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_RegisterGlCallbacks(void *jarg1, void *initCallback, int *RenderFrameCallback, void *terminateCallback) - { - Dali::GlWindow *argp1 = (Dali::GlWindow *)jarg1; - void (*initCB)() = (void (*)())initCallback; - int (*renderFrameCB)() = (int (*)())RenderFrameCallback; - void (*terminateCB)() = (void (*)())terminateCallback; - - if (!argp1 || !initCB || !renderFrameCB || !terminateCB) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null", 0); - return; - } - Dali::GlWindow arg1 = *argp1; - try - { - arg1.RegisterGlCallbacks(Dali::MakeCallback(initCB), Dali::MakeCallback(renderFrameCB), Dali::MakeCallback(terminateCB)); - } - CALL_CATCH_EXCEPTION(); - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_RenderOnce(void *jarg1) - { - Dali::GlWindow *argp1 = (Dali::GlWindow *)jarg1; - Dali::GlWindow arg1; - if (!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return; - } - arg1 = *argp1; - { - try - { - arg1.RenderOnce(); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GlWindow_GetRenderingMode(void *jarg1) - { - int jresult; - Dali::GlWindow *arg1 = (Dali::GlWindow *)0; - Dali::GlWindow::RenderingMode result; - - arg1 = (Dali::GlWindow *)jarg1; - if (!arg1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return 0; - } - - { - try - { - result = (Dali::GlWindow::RenderingMode)(arg1)->GetRenderingMode(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_SetRenderingMode(void *jarg1, int jarg2) - { - Dali::GlWindow *arg1 = (Dali::GlWindow *)0; - Dali::GlWindow::RenderingMode arg2; - - arg1 = (Dali::GlWindow *)jarg1; - if (!arg1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return; - } - arg2 = (Dali::GlWindow::RenderingMode)jarg2; - { - try - { - (arg1)->SetRenderingMode(arg2); - } - CALL_CATCH_EXCEPTION(); - } - } - - /* Signals binding*/ - - /* Focus change binding */ - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_FocusChangedSignal(void *jarg1) - { - void *jresult; - Dali::GlWindow arg1; - Dali::GlWindow *argp1; - Dali::GlWindow::FocusChangeSignalType *result = 0; - - argp1 = (Dali::GlWindow *)jarg1; - if (!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return 0; - } - arg1 = *argp1; - { - try - { - result = (Dali::GlWindow::FocusChangeSignalType *)&arg1.FocusChangeSignal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Empty(void *jarg1) - { - unsigned int jresult; - Dali::Signal *arg1 = (Dali::Signal *)0; - bool result; - - arg1 = (Dali::Signal *)jarg1; - { - try - { - result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal const *)arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; - } - - SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_GetConnectionCount(void *jarg1) - { - unsigned long jresult; - Dali::Signal *arg1 = (Dali::Signal *)0; - std::size_t result; - - arg1 = (Dali::Signal *)jarg1; - { - try - { - result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal const *)arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Connect(void *jarg1, void *jarg2) - { - Dali::Signal *arg1 = (Dali::Signal *)0; - void (*arg2)(Dali::GlWindow, bool) = (void (*)(Dali::GlWindow, bool))0; - - arg1 = (Dali::Signal *)jarg1; - arg2 = (void (*)(Dali::GlWindow, bool))jarg2; - { - try - { - Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Disconnect(void *jarg1, void *jarg2) - { - Dali::Signal *arg1 = (Dali::Signal *)0; - void (*arg2)(Dali::GlWindow, bool) = (void (*)(Dali::GlWindow, bool))0; - - arg1 = (Dali::Signal *)jarg1; - arg2 = (void (*)(Dali::GlWindow, bool))jarg2; - { - try - { - Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_FocusSignalType_Emit(void *jarg1, void *jarg2, unsigned int jarg3) - { - Dali::Signal *arg1 = (Dali::Signal *)jarg1; - Dali::GlWindow *arg2 = (Dali::GlWindow *)jarg2; - bool arg3 = jarg3 ? true : false; - ; - - if (arg1 == nullptr || arg2 == nullptr) - { - DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr"); - return; - } - - { - try - { - Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1, *arg2, arg3); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlWindow_FocusSignalType() - { - void *jresult; - Dali::Signal *result = 0; - - { - try - { - result = (Dali::Signal *)new Dali::Signal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GlWindow_FocusSignalType(void *jarg1) - { - Dali::Signal *arg1 = (Dali::Signal *)0; - - arg1 = (Dali::Signal *)jarg1; - { - try - { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } - } - - /* Touch Event Binding */ - GENERATE_SIGNAL(Dali::GlWindow*, void(*)(Dali::TouchEvent const&), Dali_GlWindow, TouchedSignal) - // CSharp_Dali_GLWindow_TouchedSignal_Connect - // CSharp_Dali_GLWindow_TouchedSignal_Disconnect - - /*Key Event Binding */ - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_KeyEventSignal(void *jarg1) - { - void *jresult; - Dali::GlWindow *arg1 = (Dali::GlWindow *)0; - Dali::GlWindow::KeyEventSignalType *result = 0; - - arg1 = (Dali::GlWindow *)jarg1; - { - try - { - result = (Dali::GlWindow::KeyEventSignalType *)&(arg1->KeyEventSignal()); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - /* visibility change */ - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal(void *jarg1) - { - Dali::GlWindow *arg1 = (Dali::GlWindow *)jarg1; - Dali::GlWindow::VisibilityChangedSignalType *result = 0; - - { - try - { - result = (Dali::GlWindow::VisibilityChangedSignalType *)&(arg1->VisibilityChangedSignal()); - } - CALL_CATCH_EXCEPTION(0); - } - return (void *)result; - } - - SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_GetConnectionCount(void *jarg1) - { - unsigned int result; - Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1; - - if (arg1 == nullptr) - { - DALI_LOG_ERROR("[ERR] arg1 == nullptr"); - return 0; - } - - { - try - { - result = arg1->GetConnectionCount(); - } - CALL_CATCH_EXCEPTION(0); - } - return result; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_Connect(void *jarg1, void *jarg2) - { - Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1; - void (*arg2)(Dali::GlWindow, bool) = (void (*)(Dali::GlWindow, bool))jarg2; - - if (arg1 == nullptr) - { - DALI_LOG_ERROR("[ERR] arg1 == nullptr"); - return; - } - - { - try - { - arg1->Connect(arg2); - } - CALL_CATCH_EXCEPTION(); - } - return; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_Disconnect(void *jarg1, void *jarg2) - { - Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1; - void (*arg2)(Dali::GlWindow, bool) = (void (*)(Dali::GlWindow, bool))jarg2; - - if (arg1 == nullptr) - { - DALI_LOG_ERROR("[ERR] arg1 == nullptr"); - return; - } - - { - try - { - arg1->Disconnect(arg2); - } - CALL_CATCH_EXCEPTION(); - } - return; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_Emit(void *jarg1, void *jarg2, bool jarg3) - { - Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1; - Dali::GlWindow *arg2 = (Dali::GlWindow *)jarg2; - bool arg3 = jarg3; - - if (arg1 == nullptr || arg2 == nullptr) - { - DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr"); - return; - } - - { - try - { - arg1->Emit(*arg2, arg3); - } - CALL_CATCH_EXCEPTION(); - } - return; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_Visibility_Changed_Signal_delete(void *jarg1) - { - Dali::GlWindow::VisibilityChangedSignalType *arg1 = (Dali::GlWindow::VisibilityChangedSignalType *)jarg1; - - { - try - { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } - return; - } - - /*ResizeSignal binding*/ - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal(void *jarg1) - { - void *jresult; - Dali::GlWindow arg1; - Dali::GlWindow *argp1; - Dali::GlWindow::ResizeSignalType *result = 0; - - argp1 = (Dali::GlWindow *)jarg1; - if (!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow", 0); - return 0; - } - arg1 = *argp1; - { - try - { - result = (Dali::GlWindow::ResizeSignalType *)&arg1.ResizeSignal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Empty(void *jarg1) - { - unsigned int jresult; - Dali::Signal *arg1 = (Dali::Signal *)0; - bool result; - - arg1 = (Dali::Signal *)jarg1; - { - try - { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Empty((Dali::Signal const *)arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; - } - - SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_GetConnectionCount(void *jarg1) - { - unsigned long jresult; - Dali::Signal *arg1 = (Dali::Signal *)0; - std::size_t result; - - arg1 = (Dali::Signal *)jarg1; - { - try - { - result = Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__GetConnectionCount((Dali::Signal const *)arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Connect(void *jarg1, void *jarg2) - { - Dali::Signal *arg1 = (Dali::Signal *)0; - void (*arg2)(Dali::GlWindow::WindowSize) = (void (*)(Dali::GlWindow::WindowSize))0; - - arg1 = (Dali::Signal *)jarg1; - arg2 = (void (*)(Dali::GlWindow::WindowSize))jarg2; - { - try - { - Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Connect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Disconnect(void *jarg1, void *jarg2) - { - Dali::Signal *arg1 = (Dali::Signal *)0; - void (*arg2)(Dali::GlWindow::WindowSize) = (void (*)(Dali::GlWindow::WindowSize))0; - - arg1 = (Dali::Signal *)jarg1; - arg2 = (void (*)(Dali::GlWindow::WindowSize))jarg2; - { - try - { - Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Disconnect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_ResizedSignal_Emit(void *jarg1, void *jarg2) - { - Dali::Signal *arg1 = (Dali::Signal *)0; - Dali::GlWindow::WindowSize arg2; - Dali::GlWindow::WindowSize *argp2; - - arg1 = (Dali::Signal *)jarg1; - if (arg1 == nullptr) - { - DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr"); - return; - } - argp2 = (Dali::GlWindow::WindowSize *)jarg2; - if (!argp2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::GlWindow::WindowSize", 0); - return; - } - arg2 = *argp2; - { - try - { - Dali_Signal_Sl_void_Sp_Dali_GlWindow_WindowSize_SP__Sg__Emit(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_GlWindow_ResizedSignal() - { - void *jresult; - Dali::Signal *result = 0; - - { - try - { - result = (Dali::Signal *)new Dali::Signal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GlWindow_delete_ResizedSignal(void *jarg1) - { - Dali::Signal *arg1 = (Dali::Signal *)0; - - arg1 = (Dali::Signal *)jarg1; - { - try - { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } - } - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/input-method-context-wrap.cpp b/dali-csharp-binder/src/input-method-context-wrap.cpp deleted file mode 100755 index 7c28e33d..00000000 --- a/dali-csharp-binder/src/input-method-context-wrap.cpp +++ /dev/null @@ -1,1931 +0,0 @@ -/* - * Copyright (c) 2020 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -/* Callback for returning strings to C# without leaking memory */ -typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -// Signals - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Empty(Dali::Signal< void (Dali::InputMethodContext &) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::InputMethodContext &) > const *self){ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Connect(Dali::Signal< void (Dali::InputMethodContext &) > *self,void (*func)(Dali::InputMethodContext &)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::InputMethodContext &) > *self,void (*func)(Dali::InputMethodContext &)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Emit(Dali::Signal< void (Dali::InputMethodContext &) > *self,Dali::InputMethodContext &arg){ - self->Emit( arg ); -} - -SWIGINTERN bool Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Empty(Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > const *self){ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Connect(Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *self,Dali::InputMethodContext::CallbackData (*func)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *self,Dali::InputMethodContext::CallbackData (*func)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &)){ - self->Disconnect( func ); -} -SWIGINTERN Dali::InputMethodContext::CallbackData Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Emit(Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *self,Dali::InputMethodContext &arg1,Dali::InputMethodContext::EventData const &arg2){ - return self->Emit( arg1, arg2 ); -} - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (bool) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (bool) > const *self){ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (bool) > *self,void (*func)(bool)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (bool) > *self,void (*func)(bool)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (bool) > *self,bool arg){ - self->Emit( arg ); -} - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Empty(Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > const *self){ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Connect(Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *self,void (*func)(Dali::InputMethodContext::KeyboardType)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Disconnect(Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *self,void (*func)(Dali::InputMethodContext::KeyboardType)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Emit(Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *self,Dali::InputMethodContext::KeyboardType arg){ - self->Emit( arg ); -} - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_int_SP__Sg__Empty(Dali::Signal< void (int) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_int_SP__Sg__GetConnectionCount(Dali::Signal< void (int) > const *self){ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_int_SP__Sg__Connect(Dali::Signal< void (int) > *self,void (*func)(int)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_int_SP__Sg__Disconnect(Dali::Signal< void (int) > *self,void (*func)(int)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_int_SP__Sg__Emit(Dali::Signal< void (int) > *self,int arg){ - self->Emit( arg ); -} - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__Empty(Dali::Signal< void (std::string const &, std::string const &, std::string const &) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__GetConnectionCount(Dali::Signal< void (std::string const &, std::string const &, std::string const &) > const *self){ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__Connect(Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *self,void (*func)(std::string const &, std::string const &, std::string const &)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__Disconnect(Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *self,void (*func)(std::string const &, std::string const &, std::string const &)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__Emit(Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *self,std::string const &arg1,std::string const &arg2,std::string const &arg3){ - self->Emit( arg1, arg2, arg3 ); -} - -// Functions - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_InputMethodContext_SWIGUpcast(Dali::InputMethodContext *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_InputMethodContext_EventData__SWIG_0() { - void * jresult ; - Dali::InputMethodContext::EventData *eventData = 0 ; - - { - try { - eventData = (Dali::InputMethodContext::EventData *)new Dali::InputMethodContext::EventData(); - } CALL_CATCH_EXCEPTION(0); } - jresult = (void *)eventData; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_InputMethodContext_EventData__SWIG_1(int csEventType, char * csPredictiveString, int csCursorOffset, int csNumberOfChars) { - void * jresult ; - Dali::InputMethodContext::EventType eventType ; - std::string *predictiveString = 0 ; - int cursorOffset ; - int numberOfChars ; - Dali::InputMethodContext::EventData *eventData = 0 ; - - eventType = (Dali::InputMethodContext::EventType)csEventType; - if (!csPredictiveString) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string predictiveStringStr(csPredictiveString); - predictiveString = &predictiveStringStr; - cursorOffset = (int)csCursorOffset; - numberOfChars = (int)csNumberOfChars; - { - try { - eventData = (Dali::InputMethodContext::EventData *)new Dali::InputMethodContext::EventData(eventType,(std::string const &)*predictiveString,cursorOffset,numberOfChars); - } CALL_CATCH_EXCEPTION(0); } - jresult = (void *)eventData; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_predictiveString_set(void* csEventData, char* csPredictiveString) { - Dali::InputMethodContext::EventData *eventData = (Dali::InputMethodContext::EventData *) 0; - std::string *resultString = 0; - - eventData = (Dali::InputMethodContext::EventData *)csEventData; - if (!csPredictiveString) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return; - } - std::string pPredictiveString(csPredictiveString); - resultString = &pPredictiveString; - if (eventData) - { - (eventData)->predictiveString = *resultString; - } - - //argout typemap for const std::string& - -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_predictiveString_get(void* csEventData) { - char* jresult; - Dali::InputMethodContext::EventData *eventData = (Dali::InputMethodContext::EventData *) 0; - std::string *result = 0; - - eventData = (Dali::InputMethodContext::EventData *)csEventData; - result = (std::string *) & ((eventData)->predictiveString); - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_eventName_set(void* csEventData, int csEventType) { - Dali::InputMethodContext::EventData *eventData = (Dali::InputMethodContext::EventData *) 0; - Dali::InputMethodContext::EventType eventType; - - eventData = (Dali::InputMethodContext::EventData *)csEventData; - eventType = (Dali::InputMethodContext::EventType)csEventType; - if (eventData) - { - (eventData)->eventName = eventType; - } -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_eventName_get(void* csEventData) { - int jresult; - Dali::InputMethodContext::EventData *eventData = (Dali::InputMethodContext::EventData *) 0; - Dali::InputMethodContext::EventType eventType; - - eventData = (Dali::InputMethodContext::EventData *)csEventData; - eventType = (Dali::InputMethodContext::EventType) ((eventData)->eventName); - jresult = (int)eventType; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_cursorOffset_set(void* csEventData, int csCursorOffset) { - Dali::InputMethodContext::EventData *eventData = (Dali::InputMethodContext::EventData *) 0; - int pCursorOffset; - - eventData = (Dali::InputMethodContext::EventData *)csEventData; - pCursorOffset = (int)csCursorOffset; - if (eventData) - { - (eventData)->cursorOffset = pCursorOffset; - } -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_cursorOffset_get(void* csEventData) { - int jresult; - Dali::InputMethodContext::EventData *eventData = (Dali::InputMethodContext::EventData *) 0; - int pCursorOffset; - - eventData = (Dali::InputMethodContext::EventData *)csEventData; - pCursorOffset = (int) ((eventData)->cursorOffset); - jresult = pCursorOffset; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_numberOfChars_set(void * csEventData, int csNumberOfChars) { - Dali::InputMethodContext::EventData *eventData = (Dali::InputMethodContext::EventData *) 0; - int pNumberOfChars; - - eventData = (Dali::InputMethodContext::EventData *)csEventData; - pNumberOfChars = (int)csNumberOfChars; - if (eventData) - { - (eventData)->numberOfChars = pNumberOfChars; - } -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_EventData_numberOfChars_get(void * csEventData) { - int jresult; - Dali::InputMethodContext::EventData *eventData = (Dali::InputMethodContext::EventData *) 0; - int pNumberOfChars; - - eventData = (Dali::InputMethodContext::EventData *)csEventData; - pNumberOfChars = (int) ((eventData)->numberOfChars); - jresult = pNumberOfChars; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_InputMethodContext_EventData(void * csEventData) { - Dali::InputMethodContext::EventData *eventData = (Dali::InputMethodContext::EventData *) 0 ; - - eventData = (Dali::InputMethodContext::EventData *)csEventData; - { - try { - delete eventData; - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_InputMethodContext_CallbackData__SWIG_0() { - void * jresult ; - Dali::InputMethodContext::CallbackData *callbackData = 0 ; - - { - try { - callbackData = (Dali::InputMethodContext::CallbackData *)new Dali::InputMethodContext::CallbackData(); - } CALL_CATCH_EXCEPTION(0); } - jresult = (void *)callbackData; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_InputMethodContext_CallbackData__SWIG_1(unsigned int csUpdate, int csCursorPosition, char * csCurrentText, unsigned int csPreeditResetRequired) { - void * jresult ; - bool isUpdated ; - int cursorPosition ; - std::string *currentText = 0 ; - bool isPreeditResetRequired ; - Dali::InputMethodContext::CallbackData *result = 0 ; - - isUpdated = csUpdate ? true : false; - cursorPosition = (int)csCursorPosition; - if (!csCurrentText) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string currentTextStr(csCurrentText); - currentText = ¤tTextStr; - isPreeditResetRequired = csPreeditResetRequired ? true : false; - { - try { - result = (Dali::InputMethodContext::CallbackData *)new Dali::InputMethodContext::CallbackData(isUpdated,cursorPosition,(std::string const &)*currentText,isPreeditResetRequired); - } CALL_CATCH_EXCEPTION(0); } - jresult = (void *)result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_currentText_set(void * csCallbackData, char * csCurrentText) { - Dali::InputMethodContext::CallbackData *callbackData = (Dali::InputMethodContext::CallbackData *) 0 ; - std::string *currentText = 0 ; - - callbackData = (Dali::InputMethodContext::CallbackData *)csCallbackData; - if (!csCurrentText) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string currentTextStr(csCurrentText); - currentText = ¤tTextStr; - if (callbackData) (callbackData)->currentText = *currentText; - - //argout typemap for const std::string& - -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_currentText_get(void * csCallbackData) { - char * jresult ; - Dali::InputMethodContext::CallbackData *callbackData = (Dali::InputMethodContext::CallbackData *) 0 ; - std::string *currentText = 0 ; - - callbackData = (Dali::InputMethodContext::CallbackData *)csCallbackData; - currentText = (std::string *) & ((callbackData)->currentText); - jresult = SWIG_csharp_string_callback(currentText->c_str()); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_cursorPosition_set(void * csCallbackData, int csCursorPosition) { - Dali::InputMethodContext::CallbackData *callbackData = (Dali::InputMethodContext::CallbackData *) 0 ; - int cursorPosition ; - - callbackData = (Dali::InputMethodContext::CallbackData *)csCallbackData; - cursorPosition = (int)csCursorPosition; - if (callbackData) (callbackData)->cursorPosition = cursorPosition; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_cursorPosition_get(void * csCallbackData) { - int jresult ; - Dali::InputMethodContext::CallbackData *callbackData = (Dali::InputMethodContext::CallbackData *) 0 ; - int result; - - callbackData = (Dali::InputMethodContext::CallbackData *)csCallbackData; - result = (int) ((callbackData)->cursorPosition); - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_update_set(void * csCallbackData, unsigned int csUpdate) { - Dali::InputMethodContext::CallbackData *callbackData = (Dali::InputMethodContext::CallbackData *) 0 ; - bool isUpdated ; - - callbackData = (Dali::InputMethodContext::CallbackData *)csCallbackData; - isUpdated = csUpdate ? true : false; - if (callbackData) (callbackData)->update = isUpdated; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_update_get(void * csCallbackData) { - unsigned int jresult ; - Dali::InputMethodContext::CallbackData *callbackData = (Dali::InputMethodContext::CallbackData *) 0 ; - bool isUpdated; - - callbackData = (Dali::InputMethodContext::CallbackData *)csCallbackData; - isUpdated = (bool) ((callbackData)->update); - jresult = isUpdated; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_preeditResetRequired_set(void * csCallbackData, unsigned int csPreeditResetRequired) { - Dali::InputMethodContext::CallbackData *callbackData = (Dali::InputMethodContext::CallbackData *) 0 ; - bool isPreeditResetRequired ; - - callbackData = (Dali::InputMethodContext::CallbackData *)csCallbackData; - isPreeditResetRequired = csPreeditResetRequired ? true : false; - if (callbackData) (callbackData)->preeditResetRequired = isPreeditResetRequired; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_InputMethodContext_CallbackData_preeditResetRequired_get(void * csCallbackData) { - unsigned int jresult ; - Dali::InputMethodContext::CallbackData *callbackData = (Dali::InputMethodContext::CallbackData *) 0 ; - bool isPreeditResetRequired; - - callbackData = (Dali::InputMethodContext::CallbackData *)csCallbackData; - isPreeditResetRequired = (bool) ((callbackData)->preeditResetRequired); - jresult = isPreeditResetRequired; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_InputMethodContext_CallbackData(void * csCallbackData) { - Dali::InputMethodContext::CallbackData *callbackData = (Dali::InputMethodContext::CallbackData *) 0 ; - - callbackData = (Dali::InputMethodContext::CallbackData *)csCallbackData; - { - try { - delete callbackData; - } CALL_CATCH_EXCEPTION(); } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_Finalize(void * csInputMethodContext) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - (inputMethodContext)->Finalize(); - } CALL_CATCH_EXCEPTION(); } -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_InputMethodContext__SWIG_0() { - void * jresult ; - Dali::InputMethodContext *inputMethodContext = 0 ; - - { - try { - inputMethodContext = (Dali::InputMethodContext *)new Dali::InputMethodContext(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)inputMethodContext; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_InputMethodContext(void * csInputMethodContext) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - delete inputMethodContext; - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_New() { - void * jresult ; - Dali::InputMethodContext inputMethodContext; - - { - try { - inputMethodContext = Dali::InputMethodContext::New( Dali::Stage::GetCurrent().GetRootLayer() ); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::InputMethodContext((const Dali::InputMethodContext &)inputMethodContext); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_InputMethodContext__SWIG_1(void * csInputMethodContext) { - void * jresult ; - Dali::InputMethodContext *inputMethodContext = 0 ; - Dali::InputMethodContext *result = 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - if (!inputMethodContext) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext const & type is null", 0); - return 0; - } - { - try { - result = (Dali::InputMethodContext *)new Dali::InputMethodContext((Dali::InputMethodContext const &)*inputMethodContext); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_Assign(void * csInputMethodContext, void * rInputMethodContext) { - void * jresult ; - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - Dali::InputMethodContext *assignedInputMethodContext = 0 ; - Dali::InputMethodContext *result = 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - assignedInputMethodContext = (Dali::InputMethodContext *)rInputMethodContext; - if (!assignedInputMethodContext) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext const & type is null", 0); - return 0; - } - { - try { - result = (Dali::InputMethodContext *) &(inputMethodContext)->operator =((Dali::InputMethodContext const &)*assignedInputMethodContext); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::InputMethodContext 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::InputMethodContext::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::InputMethodContext((const Dali::InputMethodContext &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_Activate(void * csInputMethodContext) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - (inputMethodContext)->Activate(); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_Deactivate(void * csInputMethodContext) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - (inputMethodContext)->Deactivate(); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_InputMethodContext_RestoreAfterFocusLost(void * csInputMethodContext) { - unsigned int jresult ; - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - bool status ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - status = (bool)((Dali::InputMethodContext const *)inputMethodContext)->RestoreAfterFocusLost(); - } CALL_CATCH_EXCEPTION(0); } - jresult = status; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetRestoreAfterFocusLost(void * csInputMethodContext, unsigned int csToggle) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - bool toggle ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - toggle = csToggle ? true : false; - { - try { - (inputMethodContext)->SetRestoreAfterFocusLost(toggle); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_Reset(void * csInputMethodContext) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - (inputMethodContext)->Reset(); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_NotifyCursorPosition(void * csInputMethodContext) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - (inputMethodContext)->NotifyCursorPosition(); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetCursorPosition(void * csInputMethodContext, unsigned int csCursorPosition) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - unsigned int cursorPosition ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - cursorPosition = (unsigned int)csCursorPosition; - { - try { - (inputMethodContext)->SetCursorPosition(cursorPosition); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_InputMethodContext_GetCursorPosition(void * csInputMethodContext) { - unsigned int jresult ; - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - unsigned int cursorPosition; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - cursorPosition = (unsigned int)((Dali::InputMethodContext const *)inputMethodContext)->GetCursorPosition(); - } CALL_CATCH_EXCEPTION(0); } - jresult = cursorPosition; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetSurroundingText(void * csInputMethodContext, char * csText) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - std::string *text = 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - if (!csText) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string textStr(csText); - text = &textStr; - { - try { - (inputMethodContext)->SetSurroundingText((std::string const &)*text); - } CALL_CATCH_EXCEPTION(); } - - //argout typemap for const std::string& - -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_InputMethodContext_GetSurroundingText(void * csInputMethodContext) { - char * jresult ; - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - std::string *text = 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - text = (std::string *) &((Dali::InputMethodContext const *)inputMethodContext)->GetSurroundingText(); - } CALL_CATCH_EXCEPTION(0); } - jresult = SWIG_csharp_string_callback(text->c_str()); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_NotifyTextInputMultiLine(void * csInputMethodContext, unsigned int csMultiLine) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - bool isMultiLine ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - isMultiLine = csMultiLine ? true : false; - { - try { - (inputMethodContext)->NotifyTextInputMultiLine(isMultiLine); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_GetTextDirection(void * csInputMethodContext) { - int jresult ; - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - Dali::InputMethodContext::TextDirection direction; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - direction = (Dali::InputMethodContext::TextDirection)(inputMethodContext)->GetTextDirection(); - } CALL_CATCH_EXCEPTION(0); } - jresult = (int)direction; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_GetInputMethodArea(void * csInputMethodContext) { - void * jresult ; - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - Dali::Rect< int > area; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - area = (inputMethodContext)->GetInputMethodArea(); - } CALL_CATCH_EXCEPTION(0); } - jresult = new Dali::Rect< int >((const Dali::Rect< int > &)area); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_ApplyOptions(void * csInputMethodContext, void * csInputMethodOptions) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - Dali::InputMethodOptions *inputMethodOptions = 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - inputMethodOptions = (Dali::InputMethodOptions *)csInputMethodOptions; - if (!inputMethodOptions) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InputMethodOptions const & type is null", 0); - return ; - } - { - try { - (inputMethodContext)->ApplyOptions((Dali::InputMethodOptions const &)*inputMethodOptions); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetInputPanelUserData(void * csInputMethodContext, char * csData) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - std::string *data = 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - if (!csData) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string dataStr(csData); - data = &dataStr; - { - try { - (inputMethodContext)->SetInputPanelData((std::string const &)*data); - } CALL_CATCH_EXCEPTION(); } - - //argout typemap for const std::string& - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_GetInputPanelUserData(void * csInputMethodContext, char** csData) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - std::string *data = 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - - //typemap in - std::string temp; - data = &temp; - - { - try { - (inputMethodContext)->GetInputPanelData(*data); - } CALL_CATCH_EXCEPTION(); } - - //Typemap argout in c++ file. - //This will convert c++ string to c# string - *csData = SWIG_csharp_string_callback(data->c_str()); - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_GetInputPanelState(void * csInputMethodContext) { - int jresult ; - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - Dali::InputMethodContext::State result; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - result = (Dali::InputMethodContext::State)(inputMethodContext)->GetInputPanelState(); - } CALL_CATCH_EXCEPTION(0); } - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetReturnKeyState(void * csInputMethodContext, unsigned int csVisible) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - bool isVisible ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - isVisible = csVisible ? true : false; - { - try { - (inputMethodContext)->SetReturnKeyState(isVisible); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_AutoEnableInputPanel(void * csInputMethodContext, unsigned int csEnabled) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - bool isEnabled ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - isEnabled = csEnabled ? true : false; - { - try { - (inputMethodContext)->AutoEnableInputPanel(isEnabled); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_ShowInputPanel(void * csInputMethodContext) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - (inputMethodContext)->ShowInputPanel(); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_HideInputPanel(void * csInputMethodContext) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - (inputMethodContext)->HideInputPanel(); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_GetKeyboardType(void * csInputMethodContext) { - int jresult ; - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - Dali::InputMethodContext::KeyboardType type; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - type = (Dali::InputMethodContext::KeyboardType)(inputMethodContext)->GetKeyboardType(); - } CALL_CATCH_EXCEPTION(0); } - jresult = (int)type; - return jresult; -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_InputMethodContext_GetInputPanelLocale(void * csInputMethodContext) { - char * jresult ; - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - std::string locale; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - locale = (inputMethodContext)->GetInputPanelLocale(); - } CALL_CATCH_EXCEPTION(0); } - jresult = SWIG_csharp_string_callback((&locale)->c_str()); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_AllowTextPrediction(void * csInputMethodContext, unsigned int csPrediction) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - bool prediction ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - prediction = csPrediction ? true : false; - { - try { - (inputMethodContext)->AllowTextPrediction(prediction); - } CALL_CATCH_EXCEPTION(); } -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_InputMethodContext_IsTextPredictionAllowed(void * csInputMethodContext) { - unsigned int jresult ; - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - bool prediction; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - prediction = (bool)((Dali::InputMethodContext const *)inputMethodContext)->IsTextPredictionAllowed(); - } CALL_CATCH_EXCEPTION(0); } - jresult = prediction; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetMIMEType(void * csInputMethodContext, char * csMimeTypes) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - std::string *mimeTypes = 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - if (!csMimeTypes) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string mimeTypesString(csMimeTypes); - mimeTypes = &mimeTypesString; - { - try { - (inputMethodContext)->SetContentMIMETypes((std::string const &)*mimeTypes); - } CALL_CATCH_EXCEPTION(); } - - //argout typemap for const std::string& - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetInputPanelLanguage(void * csInputMethodContext, int csLanguage) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - Dali::InputMethodContext::InputPanelLanguage language ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - if (inputMethodContext == nullptr) { - DALI_LOG_ERROR("[ERR] inputMethodContext == nullptr"); - return; - } - - language = (Dali::InputMethodContext::InputPanelLanguage)csLanguage; - { - try { - (inputMethodContext)->SetInputPanelLanguage(language); - } CALL_CATCH_EXCEPTION(); } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_InputMethodContext_GetInputPanelLanguage(void * csInputMethodContext) { - int jresult ; - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - Dali::InputMethodContext::InputPanelLanguage language; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - if (inputMethodContext == nullptr) { - DALI_LOG_ERROR("[ERR] inputMethodContext == nullptr"); - return false; - } - { - try { - language = (Dali::InputMethodContext::InputPanelLanguage)(inputMethodContext)->GetInputPanelLanguage(); - } CALL_CATCH_EXCEPTION(0); } - jresult = (int)language; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodContext_SetInputPanelPosition(void * csInputMethodContext, unsigned int csXCoord, unsigned int csYCoord) { - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - unsigned int x ; - unsigned int y ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - x = (unsigned int)csXCoord; - y = (unsigned int)csYCoord; - { - try { - (inputMethodContext)->SetInputPanelPosition(x, y); - } CALL_CATCH_EXCEPTION(); } -} - - -// Signals -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_ActivatedSignal(void * csInputMethodContext) { - void * jresult ; - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - Dali::InputMethodContext::ActivatedSignalType *type = 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - type = (Dali::InputMethodContext::ActivatedSignalType *) &(inputMethodContext)->ActivatedSignal(); - } CALL_CATCH_EXCEPTION(0); } - jresult = (void *)type; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_EventReceivedSignal(void * csInputMethodContext) { - void * jresult ; - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - Dali::InputMethodContext::KeyboardEventSignalType *type = 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - type = (Dali::InputMethodContext::KeyboardEventSignalType *) &(inputMethodContext)->EventReceivedSignal(); - } CALL_CATCH_EXCEPTION(0); } - jresult = (void *)type; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_StatusChangedSignal(void * csInputMethodContext) { - void * jresult ; - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - Dali::InputMethodContext::StatusSignalType *type = 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - type = (Dali::InputMethodContext::StatusSignalType *) &(inputMethodContext)->StatusChangedSignal(); - } CALL_CATCH_EXCEPTION(0); } - jresult = (void *)type; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_ResizedSignal(void * csInputMethodContext) { - void * jresult ; - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - Dali::InputMethodContext::KeyboardResizedSignalType *type = 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - type = (Dali::InputMethodContext::KeyboardResizedSignalType *) &(inputMethodContext)->ResizedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)type; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_LanguageChangedSignal(void * csInputMethodContext) { - void * jresult ; - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - Dali::InputMethodContext::LanguageChangedSignalType *type = 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - type = (Dali::InputMethodContext::LanguageChangedSignalType *) &(inputMethodContext)->LanguageChangedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)type; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_KeyboardTypeChangedSignal(void * csInputMethodContext) { - void * jresult ; - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - Dali::InputMethodContext::KeyboardTypeSignalType *type = 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - type = (Dali::InputMethodContext::KeyboardTypeSignalType *) &(inputMethodContext)->KeyboardTypeChangedSignal(); - } CALL_CATCH_EXCEPTION(0); } - jresult = (void *)type; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InputMethodContext_ContentReceivedSignal(void * csInputMethodContext) { - void * jresult ; - Dali::InputMethodContext *inputMethodContext = (Dali::InputMethodContext *) 0 ; - Dali::InputMethodContext::ContentReceivedSignalType *type = 0 ; - - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - { - try { - type = (Dali::InputMethodContext::ContentReceivedSignalType *) &(inputMethodContext)->ContentReceivedSignal(); - } CALL_CATCH_EXCEPTION(0); } - jresult = (void *)type; - return jresult; -} - -// ActivatedSignalType -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Empty(void * csSignal) { - unsigned int jresult ; - Dali::Signal< void (Dali::InputMethodContext &) > *signal = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ; - bool result; - - signal = (Dali::Signal< void (Dali::InputMethodContext &) > *)csSignal; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Empty((Dali::Signal< void (Dali::InputMethodContext &) > const *)signal); - } CALL_CATCH_EXCEPTION(0); } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActivatedSignalType_GetConnectionCount(void * csSignal) { - unsigned long jresult ; - Dali::Signal< void (Dali::InputMethodContext &) > *signal = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ; - std::size_t result; - - signal = (Dali::Signal< void (Dali::InputMethodContext &) > *)csSignal; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::InputMethodContext &) > const *)signal); - } CALL_CATCH_EXCEPTION(0); } - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Connect(void * csSignal, void * csInputMethodContext) { - Dali::Signal< void (Dali::InputMethodContext &) > *signal = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ; - void (*inputMethodContext)(Dali::InputMethodContext &) = (void (*)(Dali::InputMethodContext &)) 0 ; - - signal = (Dali::Signal< void (Dali::InputMethodContext &) > *)csSignal; - inputMethodContext = (void (*)(Dali::InputMethodContext &))csInputMethodContext; - { - try { - Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Connect(signal,inputMethodContext); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Disconnect(void * csSignal, void * csInputMethodContext) { - Dali::Signal< void (Dali::InputMethodContext &) > *signal = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ; - void (*inputMethodContext)(Dali::InputMethodContext &) = (void (*)(Dali::InputMethodContext &)) 0 ; - - signal = (Dali::Signal< void (Dali::InputMethodContext &) > *)csSignal; - inputMethodContext = (void (*)(Dali::InputMethodContext &))csInputMethodContext; - { - try { - Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Disconnect(signal,inputMethodContext); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActivatedSignalType_Emit(void * csSignal, void * csInputMethodContext) { - Dali::Signal< void (Dali::InputMethodContext &) > *signal = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ; - Dali::InputMethodContext *inputMethodContext = 0 ; - - signal = (Dali::Signal< void (Dali::InputMethodContext &) > *)csSignal; - inputMethodContext = (Dali::InputMethodContext *)csInputMethodContext; - if (!inputMethodContext) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext & type is null", 0); - return ; - } - { - try { - Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_SA__SP__Sg__Emit(signal,*inputMethodContext); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActivatedSignalType() { - void * jresult ; - Dali::Signal< void (Dali::InputMethodContext &) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::InputMethodContext &) > *)new Dali::Signal< void (Dali::InputMethodContext &) >(); - } CALL_CATCH_EXCEPTION(0); } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActivatedSignalType(void * csSignal) { - Dali::Signal< void (Dali::InputMethodContext &) > *signal = (Dali::Signal< void (Dali::InputMethodContext &) > *) 0 ; - - signal = (Dali::Signal< void (Dali::InputMethodContext &) > *)csSignal; - { - try { - delete signal; - } CALL_CATCH_EXCEPTION(); } -} - -// KeyboardEventSignalType -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Empty(void * csEventData) { - unsigned int jresult ; - Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)csEventData; - { - try { - result = (bool)Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Empty((Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_GetConnectionCount(void * csEventData) { - unsigned long jresult ; - Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)csEventData; - { - try { - result = Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); } - jresult = (unsigned long)result; - return jresult; -} - -typedef Dali::InputMethodContext::CallbackData* (SWIGSTDCALL* SWIG_CallbackEventReceived)(Dali::InputMethodContext *, Dali::InputMethodContext::EventData *); -SWIG_CallbackEventReceived swig_callbackOnEventReceived; - -Dali::InputMethodContext::CallbackData OnEventReceivedCallback(Dali::InputMethodContext inputMethodContext, Dali::InputMethodContext::EventData eventData) -{ - Dali::InputMethodContext::CallbackData *callbackDataP; - Dali::InputMethodContext::CallbackData callbackData; - Dali::InputMethodContext *inputMethodContextP = NULL; - Dali::InputMethodContext::EventData *eventDataP = NULL; - - if (inputMethodContext) - { - inputMethodContextP = (Dali::InputMethodContext *)&inputMethodContext; - } - - eventDataP = (Dali::InputMethodContext::EventData *)&eventData; - - callbackDataP = (Dali::InputMethodContext::CallbackData *)swig_callbackOnEventReceived(inputMethodContextP, eventDataP); - if (callbackDataP) - { - callbackData = *callbackDataP; - } - - return callbackData; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Connect(void * jarg1, SWIG_CallbackEventReceived callbackOnEventReceived) { - - swig_callbackOnEventReceived = callbackOnEventReceived; - - Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ; - Dali::InputMethodContext::CallbackData (*arg2)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &)) 0 ; - - arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1; - arg2 = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &))OnEventReceivedCallback; - { - try { - Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Disconnect(void * jarg1, SWIG_CallbackEventReceived callbackOnEventReceived) { - - swig_callbackOnEventReceived = callbackOnEventReceived; - - Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ; - Dali::InputMethodContext::CallbackData (*arg2)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &)) 0 ; - - arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1; - arg2 = (Dali::InputMethodContext::CallbackData (*)(Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &))OnEventReceivedCallback; - { - try { - Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); } -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyboardEventSignalType_Emit(void * jarg1, void * jarg2, void * jarg3) { - void * jresult ; - Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ; - Dali::InputMethodContext *arg2 = 0 ; - Dali::InputMethodContext::EventData *arg3 = 0 ; - Dali::InputMethodContext::CallbackData result; - - arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1; - arg2 = (Dali::InputMethodContext *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext & type is null", 0); - return 0; - } - arg3 = (Dali::InputMethodContext::EventData *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::InputMethodContext::EventData const & type is null", 0); - return 0; - } - { - try { - result = Dali_Signal_Sl_Dali_InputMethodContext_CallbackData_Sp_Dali_InputMethodContext_SA__Sc_Dali_InputMethodContext_EventData_SS_const_SA__SP__Sg__Emit(arg1,*arg2,(Dali::InputMethodContext::EventData const &)*arg3); - } CALL_CATCH_EXCEPTION(0); } - jresult = new Dali::InputMethodContext::CallbackData((const Dali::InputMethodContext::CallbackData &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyboardEventSignalType() { - void * jresult ; - Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *result = 0 ; - - { - try { - result = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)new Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) >(); - } CALL_CATCH_EXCEPTION(0); } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyboardEventSignalType(void * jarg1) { - Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *) 0 ; - - arg1 = (Dali::Signal< Dali::InputMethodContext::CallbackData (Dali::InputMethodContext &,Dali::InputMethodContext::EventData const &) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); } -} - - -// VoidSignalType -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignalType() { - void * jresult ; - Dali::Signal< void () > *result = 0 ; - - { - try { - result = (Dali::Signal< void () > *)new Dali::Signal< void () >(); - } CALL_CATCH_EXCEPTION(0); } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignalType(void * jarg1) { - Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; - - arg1 = (Dali::Signal< void () > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignalType_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void () > *)jarg1; - { - try { - result = (bool)((Dali::Signal< void () > const *)arg1)->Empty(); - } CALL_CATCH_EXCEPTION(0); } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignalType_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void () > *)jarg1; - { - try { - result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount(); - } CALL_CATCH_EXCEPTION(0); } - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Connect__SWIG_0(void * jarg1, void * jarg2) { - Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; - void (*arg2)() = (void (*)()) 0 ; - - arg1 = (Dali::Signal< void () > *)jarg1; - arg2 = (void (*)())jarg2; - { - try { - (arg1)->Connect(arg2); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; - void (*arg2)() = (void (*)()) 0 ; - - arg1 = (Dali::Signal< void () > *)jarg1; - arg2 = (void (*)())jarg2; - { - try { - (arg1)->Disconnect(arg2); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) { - Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; - Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ; - Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ; - - arg1 = (Dali::Signal< void () > *)jarg1; - arg2 = (Dali::ConnectionTrackerInterface *)jarg2; - arg3 = (Dali::FunctorDelegate *)jarg3; - { - try { - (arg1)->Connect(arg2,arg3); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignalType_Emit(void * jarg1) { - Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ; - - arg1 = (Dali::Signal< void () > *)jarg1; - { - try { - (arg1)->Emit(); - } CALL_CATCH_EXCEPTION(); } -} - -//StatusSignalType -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StatusSignalType_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (bool) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StatusSignalType_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (bool) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); } - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StatusSignalType_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ; - void (*arg2)(bool) = (void (*)(bool)) 0 ; - - arg1 = (Dali::Signal< void (bool) > *)jarg1; - arg2 = (void (*)(bool))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StatusSignalType_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ; - void (*arg2)(bool) = (void (*)(bool)) 0 ; - - arg1 = (Dali::Signal< void (bool) > *)jarg1; - arg2 = (void (*)(bool))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StatusSignalType_Emit(void * jarg1, unsigned int jarg2) { - Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ; - bool arg2 ; - - arg1 = (Dali::Signal< void (bool) > *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StatusSignalType() { - void * jresult ; - Dali::Signal< void (bool) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >(); - } CALL_CATCH_EXCEPTION(0); } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StatusSignalType(void * jarg1) { - Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ; - - arg1 = (Dali::Signal< void (bool) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); } -} - -//KeyboardTypeSignalType -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Empty((Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); } - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ; - void (*arg2)(Dali::InputMethodContext::KeyboardType) = (void (*)(Dali::InputMethodContext::KeyboardType)) 0 ; - - arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1; - arg2 = (void (*)(Dali::InputMethodContext::KeyboardType))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ; - void (*arg2)(Dali::InputMethodContext::KeyboardType) = (void (*)(Dali::InputMethodContext::KeyboardType)) 0 ; - - arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1; - arg2 = (void (*)(Dali::InputMethodContext::KeyboardType))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardTypeSignalType_Emit(void * jarg1, int jarg2) { - Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ; - Dali::InputMethodContext::KeyboardType arg2 ; - - arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1; - arg2 = (Dali::InputMethodContext::KeyboardType)jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_InputMethodContext_KeyboardType_SP__Sg__Emit(arg1,arg2); - } CALL_CATCH_EXCEPTION(); } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyboardTypeSignalType() { - void * jresult ; - Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)new Dali::Signal< void (Dali::InputMethodContext::KeyboardType) >(); - } CALL_CATCH_EXCEPTION(0); } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyboardTypeSignalType(void * jarg1) { - Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::InputMethodContext::KeyboardType) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); } -} - -//LanguageChangedSignalType - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (int) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_int_SP__Sg__Empty((Dali::Signal< void (int) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (int) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_int_SP__Sg__GetConnectionCount((Dali::Signal< void (int) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; - void (*arg2)(int) = (void (*)(int)) 0 ; - - arg1 = (Dali::Signal< void (int) > *)jarg1; - arg2 = (void (*)(int))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_int_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; - void (*arg2)(int) = (void (*)(int)) 0 ; - - arg1 = (Dali::Signal< void (int) > *)jarg1; - arg2 = (void (*)(int))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_int_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LanguageChangedSignalType_Emit(void * jarg1, int jarg2) { - Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; - int arg2 ; - - arg1 = (Dali::Signal< void (int) > *)jarg1; - arg2 = (int)jarg2; - { - try { - Dali_Signal_Sl_void_Sp_int_SP__Sg__Emit(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LanguageChangedSignalType() { - void * jresult ; - Dali::Signal< void (int) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (int) > *)new Dali::Signal< void (int) >(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LanguageChangedSignalType(void * jarg1) { - Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; - - arg1 = (Dali::Signal< void (int) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -//KeyboardTypeSignalType - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (int) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_int_SP__Sg__Empty((Dali::Signal< void (int) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (int) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_int_SP__Sg__GetConnectionCount((Dali::Signal< void (int) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; - void (*arg2)(int) = (void (*)(int)) 0 ; - - arg1 = (Dali::Signal< void (int) > *)jarg1; - arg2 = (void (*)(int))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_int_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; - void (*arg2)(int) = (void (*)(int)) 0 ; - - arg1 = (Dali::Signal< void (int) > *)jarg1; - arg2 = (void (*)(int))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_int_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyboardResizedSignalType_Emit(void * jarg1, int jarg2) { - Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; - int arg2 ; - - arg1 = (Dali::Signal< void (int) > *)jarg1; - arg2 = (int)jarg2; - { - try { - Dali_Signal_Sl_void_Sp_int_SP__Sg__Emit(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyboardResizedSignalType() { - void * jresult ; - Dali::Signal< void (int) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (int) > *)new Dali::Signal< void (int) >(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyboardResizedSignalType(void * jarg1) { - Dali::Signal< void (int) > *arg1 = (Dali::Signal< void (int) > *) 0 ; - - arg1 = (Dali::Signal< void (int) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -//ContentReceivedSignalType - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ContentReceivedSignalType_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__Empty((Dali::Signal< void (std::string const &, std::string const &, std::string const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ContentReceivedSignalType_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__GetConnectionCount((Dali::Signal< void (std::string const &, std::string const &, std::string const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ContentReceivedSignalType_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *) 0 ; - void (*arg2)(std::string const &, std::string const &, std::string const &) = (void (*)(std::string const &, std::string const &, std::string const &)) 0 ; - - arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *)jarg1; - arg2 = (void (*)(std::string const &, std::string const &, std::string const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ContentReceivedSignalType_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *) 0 ; - void (*arg2)(std::string const &, std::string const &, std::string const &) = (void (*)(std::string const &, std::string const &, std::string const &)) 0 ; - - arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *)jarg1; - arg2 = (void (*)(std::string const &, std::string const &, std::string const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ContentReceivedSignalType_Emit(void * jarg1, char * jarg2, char * jarg3, char * jarg4) { - Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *) 0 ; - std::string *arg2 = 0 ; - std::string *arg3 = 0 ; - std::string *arg4 = 0 ; - - arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *)jarg1; - std::string arg2_str(jarg2); - arg2 = &arg2_str; - std::string arg3_str(jarg3); - arg3 = &arg3_str; - std::string arg4_str(jarg4); - arg4 = &arg4_str; - { - try { - Dali_Signal_Sl_void_Sp_string_string_string_SP__Sg__Emit(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ContentReceivedSignalType() { - void * jresult ; - Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *)new Dali::Signal< void (std::string const &, std::string const &, std::string const &) >(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ContentReceivedSignalType(void * jarg1) { - Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *) 0 ; - - arg1 = (Dali::Signal< void (std::string const &, std::string const &, std::string const &) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/input-method-options-wrap.cpp b/dali-csharp-binder/src/input-method-options-wrap.cpp deleted file mode 100755 index 344daaa7..00000000 --- a/dali-csharp-binder/src/input-method-options-wrap.cpp +++ /dev/null @@ -1,114 +0,0 @@ -/* - * Copyright (c) 2017 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_InputMethodOptions() { - void * jresult ; - Dali::InputMethodOptions *result = 0 ; - - { - try { - result = (Dali::InputMethodOptions *)new Dali::InputMethodOptions(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_InputMethodOptions_IsPassword(void * jarg1) { - unsigned int jresult ; - Dali::InputMethodOptions *arg1 = (Dali::InputMethodOptions *) 0 ; - bool result; - - arg1 = (Dali::InputMethodOptions *)jarg1; - { - try { - result = (bool)(arg1)->IsPassword(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodOptions_ApplyProperty(void * jarg1, void * jarg2) { - Dali::InputMethodOptions *arg1 = (Dali::InputMethodOptions *) 0 ; - Dali::Property::Map *arg2 = 0 ; - - arg1 = (Dali::InputMethodOptions *)jarg1; - arg2 = (Dali::Property::Map *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0); - return ; - } - { - try { - (arg1)->ApplyProperty((Dali::Property::Map const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_InputMethodOptions_RetrieveProperty(void * jarg1, void * jarg2) { - Dali::InputMethodOptions *arg1 = (Dali::InputMethodOptions *) 0 ; - Dali::Property::Map *arg2 = 0 ; - - arg1 = (Dali::InputMethodOptions *)jarg1; - arg2 = (Dali::Property::Map *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0); - return ; - } - { - try { - (arg1)->RetrieveProperty(*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_InputMethodOptions(void * jarg1) { - Dali::InputMethodOptions *arg1 = (Dali::InputMethodOptions *) 0 ; - - arg1 = (Dali::InputMethodOptions *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/input-options-wrap.cpp b/dali-csharp-binder/src/input-options-wrap.cpp deleted file mode 100644 index c777000d..00000000 --- a/dali-csharp-binder/src/input-options-wrap.cpp +++ /dev/null @@ -1,258 +0,0 @@ -/* - * Copyright (c) 2021 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - -using namespace Dali; - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGesturePredictionMode(int mode) { - { - try { - Integration::SetPanGesturePredictionMode(mode); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGesturePredictionAmount(unsigned int amount) { - { - try { - Integration::SetPanGesturePredictionAmount(amount); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureMaximumPredictionAmount(unsigned int amount) { - { - try { - Integration::SetPanGestureMaximumPredictionAmount(amount); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureMinimumPredictionAmount(unsigned int amount) { - { - try { - Integration::SetPanGestureMinimumPredictionAmount(amount); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGesturePredictionAmountAdjustment(unsigned int amount) { - { - try { - Integration::SetPanGesturePredictionAmountAdjustment(amount); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureSmoothingMode(int mode) { - { - try { - Integration::SetPanGestureSmoothingMode(mode); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureSmoothingAmount(float amount) { - { - try { - Integration::SetPanGestureSmoothingAmount(amount); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureUseActualTimes(bool enable) { - { - try { - Integration::SetPanGestureUseActualTimes(enable); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureInterpolationTimeRange(int range) { - { - try { - Integration::SetPanGestureInterpolationTimeRange(range); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureScalarOnlyPredictionEnabled(bool enable) { - { - try { - Integration::SetPanGestureScalarOnlyPredictionEnabled(enable); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureTwoPointPredictionEnabled(bool enable) { - { - try { - Integration::SetPanGestureTwoPointPredictionEnabled(enable); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureTwoPointInterpolatePastTime(int time) { - { - try { - Integration::SetPanGestureTwoPointInterpolatePastTime(time); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureTwoPointVelocityBias(float velocity) { - { - try { - Integration::SetPanGestureTwoPointVelocityBias(velocity); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureTwoPointAccelerationBias(float acceleration) { - { - try { - Integration::SetPanGestureTwoPointAccelerationBias(acceleration); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureMultitapSmoothingRange(int range) { - { - try { - Integration::SetPanGestureMultitapSmoothingRange(range); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureMinimumDistance(int distance) { - { - try { - Integration::SetPanGestureMinimumDistance(distance); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureMinimumPanEvents(int number) { - { - try { - Integration::SetPanGestureMinimumPanEvents(number); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPinchGestureMinimumDistance(float distance) { - { - try { - Integration::SetPinchGestureMinimumDistance(distance); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPinchGestureMinimumTouchEvents(unsigned int number) { - { - try { - Integration::SetPinchGestureMinimumTouchEvents(number); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPinchGestureMinimumTouchEventsAfterStart(unsigned int number) { - { - try { - Integration::SetPinchGestureMinimumTouchEventsAfterStart(number); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetRotationGestureMinimumTouchEvents(unsigned int number) { - { - try { - Integration::SetRotationGestureMinimumTouchEvents(number); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetRotationGestureMinimumTouchEventsAfterStart(unsigned int number) { - { - try { - Integration::SetRotationGestureMinimumTouchEventsAfterStart(number); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetLongPressMinimumHoldingTime(unsigned int time) { - { - try { - Integration::SetLongPressMinimumHoldingTime(time); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetTapMaximumAllowedTime(uint32_t time) { - { - try { - Integration::SetTapMaximumAllowedTime(time); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetTapRecognizerTime(uint32_t time) { - { - try { - Integration::SetTapRecognizerTime(time); - } CALL_CATCH_EXCEPTION(); - } - return; -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/internal-property-get-set-wrap.cpp b/dali-csharp-binder/src/internal-property-get-set-wrap.cpp deleted file mode 100755 index 0e8c32a5..00000000 --- a/dali-csharp-binder/src/internal-property-get-set-wrap.cpp +++ /dev/null @@ -1,593 +0,0 @@ -/* - * Copyright (c) 2022 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - - typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); - extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - - enum InternalPropertyReturnType - { - NO_ERROR = 0, - ERROR_UNKNOWN = 1, - ERROR_IMPOSSIBLE_SET = 2, - }; - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalSetPropertyVector2(void *actor, int propertyType, void *vector2) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - Dali::Vector2 *pVector2 = (Dali::Vector2 *)vector2; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - if (!pVector2) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector2 is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - pActor->SetProperty((Dali::Property::Index)propertyType, *pVector2); - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalSetPropertyVector3(void *actor, int propertyType, void *vector3) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - Dali::Vector3 *pVector3 = (Dali::Vector3 *)vector3; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - if (!pVector3) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector3 is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - pActor->SetProperty((Dali::Property::Index)propertyType, *pVector3); - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalSetPropertyVector4(void *actor, int propertyType, void *vector4) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - Dali::Vector4 *pVector4 = (Dali::Vector4 *)vector4; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - if (!pVector4) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector4 is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - pActor->SetProperty((Dali::Property::Index)propertyType, *pVector4); - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalSetPropertyVector2ActualVector3(void *actor, int propertyType, void *vector2) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - Dali::Vector2 *pVector2 = (Dali::Vector2 *)vector2; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - if (!pVector2) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector2 is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - pActor->SetProperty((Dali::Property::Index)propertyType, Dali::Vector3(pVector2->x, pVector2->y, 0)); - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalSetPropertyFloat(void *actor, int propertyType, float valFloat) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - pActor->SetProperty((Dali::Property::Index)propertyType, valFloat); - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalSetPropertyBool(void *actor, int propertyType, bool valBool) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - pActor->SetProperty((Dali::Property::Index)propertyType, valBool); - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalSetPropertyString(void *actor, int propertyType, char *valString) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - if (!valString) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "valString is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - pActor->SetProperty((Dali::Property::Index)propertyType, (std::string const &)std::string(valString)); - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalSetPropertyInt(void *actor, int propertyType, int valInt) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - pActor->SetProperty((Dali::Property::Index)propertyType, valInt); - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalRetrievingPropertyVector2(void *actor, int propertyType, void *retrievingVector2) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - Dali::Vector2 *pVector2 = (Dali::Vector2 *)retrievingVector2; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - if (!pVector2) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector2 is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - Dali::Vector2 result; - result = ((Dali::Actor const *)pActor)->GetProperty((Dali::Property::Index)propertyType); - pVector2->x = result.x; - pVector2->y = result.y; - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalRetrievingPropertyVector3(void *actor, int propertyType, void *retrievingVector3) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - Dali::Vector3 *pVector3 = (Dali::Vector3 *)retrievingVector3; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - if (!pVector3) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector3 is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - Dali::Vector3 result; - result = ((Dali::Actor const *)pActor)->GetProperty((Dali::Property::Index)propertyType); - pVector3->x = result.x; - pVector3->y = result.y; - pVector3->z = result.z; - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalRetrievingPropertyVector4(void *actor, int propertyType, void *retrievingVector4) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - Dali::Vector4 *pVector4 = (Dali::Vector4 *)retrievingVector4; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - if (!pVector4) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector4 is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - Dali::Vector4 result; - result = ((Dali::Actor const *)pActor)->GetProperty((Dali::Property::Index)propertyType); - pVector4->x = result.x; - pVector4->y = result.y; - pVector4->z = result.z; - pVector4->w = result.w; - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalRetrievingPropertyVector2ActualVector3(void *actor, int propertyType, void *retrievingVector2) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - Dali::Vector2 *pVector2 = (Dali::Vector2 *)retrievingVector2; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - if (!pVector2) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector2 is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - Dali::Vector3 result; - result = ((Dali::Actor const *)pActor)->GetProperty((Dali::Property::Index)propertyType); - pVector2->x = result.x; - pVector2->y = result.y; - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalRetrievingPropertyFloat(void *actor, int propertyType, float *valFloat) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - if (!valFloat) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "valFloat is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - *valFloat = ((Dali::Actor const *)pActor)->GetProperty((Dali::Property::Index)propertyType); - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_InternalGetPropertyFloat(void *actor, int propertyType) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - float ret = 0; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return ret; - } - - try - { - ret = ((Dali::Actor const *)pActor)->GetProperty((Dali::Property::Index)propertyType); - } - CALL_CATCH_EXCEPTION(ret); - - return ret; - } - - SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_InternalGetPropertyBool(void *actor, int propertyType) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - bool ret = false; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return ret; - } - - try - { - ret = ((Dali::Actor const *)pActor)->GetProperty((Dali::Property::Index)propertyType); - } - CALL_CATCH_EXCEPTION(ret); - - return ret; - } - - SWIGEXPORT char *SWIGSTDCALL CSharp_Dali_Actor_InternalGetPropertyString(void *actor, int propertyType) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - std::string result = ""; - char *ret = nullptr; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return ret; - } - - try - { - result = ((Dali::Actor const *)pActor)->GetProperty((Dali::Property::Index)propertyType); - ret = SWIG_csharp_string_callback(result.c_str()); - } - CALL_CATCH_EXCEPTION(ret); - - return ret; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalGetPropertyInt(void *actor, int propertyType) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - int ret = 0; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return ret; - } - - try - { - ret = ((Dali::Actor const *)pActor)->GetProperty((Dali::Property::Index)propertyType); - } - CALL_CATCH_EXCEPTION(ret); - - return ret; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_RetrieveTargetSize(void *actor, void *retrievingVector3) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - Dali::Vector3 *pVector3 = (Dali::Vector3 *)retrievingVector3; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - if (!pVector3) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector3 is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - Dali::Vector3 result; - result = ((Dali::Actor const *)pActor)->GetTargetSize(); - pVector3->x = result.x; - pVector3->y = result.y; - pVector3->z = result.z; - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_RetrieveCurrentPropertyVector3(void *actor, int propertyType, void *retrievingVector3) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - Dali::Vector3 *pVector3 = (Dali::Vector3 *)retrievingVector3; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - if (!pVector3) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector3 is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - Dali::Vector3 result; - result = ((Dali::Actor const *)pActor)->GetCurrentProperty((Dali::Property::Index)propertyType); - pVector3->x = result.x; - pVector3->y = result.y; - pVector3->z = result.z; - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_RetrieveCurrentPropertyVector2ActualVector3(void *actor, int propertyType, void *retrievingVector2) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - Dali::Vector2 *pVector2 = (Dali::Vector2 *)retrievingVector2; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - if (!pVector2) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector2 is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - Dali::Vector3 result; - result = ((Dali::Actor const *)pActor)->GetCurrentProperty((Dali::Property::Index)propertyType); - pVector2->x = result.x; - pVector2->y = result.y; - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_RetrieveNaturalSize(void *actor, void *retrievingVector3) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - Dali::Vector3 *pVector3 = (Dali::Vector3 *)retrievingVector3; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - if (!pVector3) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector3 is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - Dali::Vector3 result; - result = ((Dali::Actor const *)pActor)->GetNaturalSize(); - pVector3->x = result.x; - pVector3->y = result.y; - pVector3->z = result.z; - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_RetrieveCurrentPropertyVector4(void *actor, int propertyType, void *retrievingVector4) - { - Dali::Actor *pActor = (Dali::Actor *)actor; - Dali::Vector4 *pVector4 = (Dali::Vector4 *)retrievingVector4; - - if (!pActor) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - if (!pVector4) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector4 is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - Dali::Vector4 result; - result = ((Dali::Actor const *)pActor)->GetCurrentProperty((Dali::Property::Index)propertyType); - pVector4->x = result.x; - pVector4->y = result.y; - pVector4->z = result.z; - pVector4->w = result.w; - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/internal-visual-property-get-set-wrap.cpp b/dali-csharp-binder/src/internal-visual-property-get-set-wrap.cpp deleted file mode 100755 index dd135dad..00000000 --- a/dali-csharp-binder/src/internal-visual-property-get-set-wrap.cpp +++ /dev/null @@ -1,378 +0,0 @@ -/* - * Copyright (c) 2022 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include -#include -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - - typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); - extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - - enum InternalPropertyReturnType - { - NO_ERROR = 0, - ERROR_UNKNOWN = 1, - ERROR_IMPOSSIBLE_SET = 2, - }; - - // Update visual property by Action::UPDATE_PROPERTY. - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_InternalUpdateVisualPropertyBool(void *view, int visualIndex, int visualPropertyIndex, bool valBool) - { - Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; - - if (!pControl) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - Dali::Property::Map tempMap; - tempMap.Insert(visualPropertyIndex, valBool); - Dali::Toolkit::DevelControl::DoAction(*pControl, visualIndex, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, std::move(tempMap)); - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_InternalUpdateVisualPropertyFloat(void *view, int visualIndex, int visualPropertyIndex, float valFloat) - { - Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; - - if (!pControl) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - Dali::Property::Map tempMap; - tempMap.Insert(visualPropertyIndex, valFloat); - Dali::Toolkit::DevelControl::DoAction(*pControl, visualIndex, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, std::move(tempMap)); - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_InternalUpdateVisualPropertyInt(void *view, int visualIndex, int visualPropertyIndex, int valInt) - { - Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; - - if (!pControl) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - Dali::Property::Map tempMap; - tempMap.Insert(visualPropertyIndex, valInt); - Dali::Toolkit::DevelControl::DoAction(*pControl, visualIndex, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, std::move(tempMap)); - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_InternalUpdateVisualPropertyIntPair(void *view, int visualIndex, int visualPropertyIndex, int valInt1, int valInt2) - { - Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; - - if (!pControl) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - Dali::Property::Array tempArray; - tempArray.Add(Dali::Property::Value(valInt1)); - tempArray.Add(Dali::Property::Value(valInt2)); - Dali::Property::Map tempMap; - tempMap.Insert(visualPropertyIndex, std::move(tempArray)); - Dali::Toolkit::DevelControl::DoAction(*pControl, visualIndex, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, std::move(tempMap)); - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_InternalUpdateVisualPropertyString(void *view, int visualIndex, int visualPropertyIndex, char* valString) - { - Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; - - if (!pControl) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - if (!valString) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "valString1 is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - Dali::Property::Map tempMap; - tempMap.Insert(visualPropertyIndex, std::move(valString)); - Dali::Toolkit::DevelControl::DoAction(*pControl, visualIndex, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, std::move(tempMap)); - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_InternalUpdateVisualPropertyStringPair(void *view, int visualIndex, int visualPropertyIndex, char* valString1, char* valString2) - { - Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; - - if (!pControl) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - if (!valString1) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "valString1 is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - if (!valString2) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "valString2 is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - Dali::Property::Array tempArray; - tempArray.Add(Dali::Property::Value(valString1)); - tempArray.Add(Dali::Property::Value(valString2)); - Dali::Property::Map tempMap; - tempMap.Insert(visualPropertyIndex, std::move(tempArray)); - Dali::Toolkit::DevelControl::DoAction(*pControl, visualIndex, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, std::move(tempMap)); - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_InternalUpdateVisualPropertyVector4(void *view, int visualIndex, int visualPropertyIndex, void *vector4) - { - Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; - const Dali::Vector4 *pVector4 = (const Dali::Vector4 *)vector4; - - if (!pControl) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - if (!pVector4) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector4 is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - Dali::Property::Map tempMap; - tempMap.Insert(visualPropertyIndex, *pVector4); - Dali::Toolkit::DevelControl::DoAction(*pControl, visualIndex, Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY, std::move(tempMap)); - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - // Other Actions witch is not Action::UPDATE_PROPERTY. - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoActionWithEmptyAttributes(void *view, int visualIndex, int actionId) - { - Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; - - if (!pControl) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0); - return; - } - { - try { - Dali::Toolkit::DevelControl::DoAction(*pControl, visualIndex, actionId, Dali::Property::Value()); - } CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoActionWithSingleIntAttributes(void *view, int visualIndex, int actionId, int actionValue) - { - Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; - - if (!pControl) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0); - return; - } - { - try { - Dali::Toolkit::DevelControl::DoAction(*pControl, visualIndex, actionId, Dali::Property::Value(actionValue)); - } CALL_CATCH_EXCEPTION(); - } - } - - // Get value from visual - // NOTE : Control.GetProperty(visualIndex) is not enought because it cannot get custom registed visual. - // NOTE : Currently, there is no way to get value from visual directly. We need to use CreatePropertyMap. - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalRetrievingVisualPropertyInt(void *view, int visualIndex, int visualPropertyIndex, int *valInt) - { - Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; - - if (!pControl) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - if (!valInt) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "valInt is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - Dali::Toolkit::Internal::Control& internalControl = Dali::Toolkit::Internal::GetImplementation(*pControl); - Dali::Toolkit::Visual::Base visualBase = Dali::Toolkit::DevelControl::GetVisual(internalControl, visualIndex); - if(visualBase) - { - Dali::Property::Map tempMap; - visualBase.CreatePropertyMap(tempMap); - Dali::Property::Value* retValuePtr = tempMap.Find(visualPropertyIndex); - if(retValuePtr) - { - *valInt = retValuePtr->Get(); - } - } - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalRetrievingVisualPropertyString(void *view, int visualIndex, int visualPropertyIndex, char** valString) - { - Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; - - if (!pControl) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - if (!valString) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "valString is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - // Copy inputed initialized string. - // Note : C# side inputed string reference count become reduced. - // So, If we want to keep life when we fail to get result, - // We should re-convert by SWIG_csharp_string_callback. - std::string temp = (*valString == nullptr) ? "" : *valString; - - Dali::Toolkit::Internal::Control& internalControl = Dali::Toolkit::Internal::GetImplementation(*pControl); - Dali::Toolkit::Visual::Base visualBase = Dali::Toolkit::DevelControl::GetVisual(internalControl, visualIndex); - if(visualBase) - { - Dali::Property::Map tempMap; - visualBase.CreatePropertyMap(tempMap); - Dali::Property::Value* retValuePtr = tempMap.Find(visualPropertyIndex); - if(retValuePtr) - { - //typemap in - temp = retValuePtr->Get(); - } - } - - //Typemap argout in c++ file. - //This will convert c++ string to c# string - *valString = SWIG_csharp_string_callback(temp.c_str()); - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_InternalRetrievingVisualPropertyVector4(void *view, int visualIndex, int visualPropertyIndex, void *vector4) - { - Dali::Toolkit::Control *pControl = (Dali::Toolkit::Control *)view; - Dali::Vector4 *pVector4 = (Dali::Vector4 *)vector4; - - if (!pControl) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "view is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - if (!pVector4) - { - SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "vector4 is null!"); - return (int)InternalPropertyReturnType::ERROR_UNKNOWN; - } - - try - { - Dali::Toolkit::Internal::Control& internalControl = Dali::Toolkit::Internal::GetImplementation(*pControl); - Dali::Toolkit::Visual::Base visualBase = Dali::Toolkit::DevelControl::GetVisual(internalControl, visualIndex); - if(visualBase) - { - Dali::Property::Map tempMap; - visualBase.CreatePropertyMap(tempMap); - Dali::Property::Value* retValuePtr = tempMap.Find(visualPropertyIndex); - if(retValuePtr) - { - *pVector4 = retValuePtr->Get(); - } - } - } - CALL_CATCH_EXCEPTION((int)InternalPropertyReturnType::ERROR_UNKNOWN); - - return (int)InternalPropertyReturnType::NO_ERROR; - } -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/key-grab-wrap.cpp b/dali-csharp-binder/src/key-grab-wrap.cpp deleted file mode 100755 index 96de3182..00000000 --- a/dali-csharp-binder/src/key-grab-wrap.cpp +++ /dev/null @@ -1,157 +0,0 @@ -/* - * Copyright (c) 2017 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - - -#ifdef TIZEN_BUILD -#ifdef ECORE_WL2 -#include -#else -#include -#endif -#endif - -#undef LOG -//#define LOG DALI_LOG_ERROR -#define LOG(a...) - - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GrabKeyTopmost(void * window, int daliKey) -{ - Dali::Window *_win = (Dali::Window *)window; - bool ret; - - LOG("CSharp_Dali_GrabKeyTopmost() [DP1] window=%d, dalikey=%d", window, daliKey); - - { - try { - ret = Dali::KeyGrab::GrabKeyTopmost(*_win, (Dali::KEY)daliKey); - } CALL_CATCH_EXCEPTION(0); - } - - - LOG("CSharp_Dali_GrabKeyTopmost() [DP2] ret=%d", ret); - - return ret; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_UngrabKeyTopmost(void * window, int daliKey) -{ - Dali::Window *_win = (Dali::Window *)window; - bool ret; - - LOG("CSharp_Dali_UngrabKeyTopmost() [DP1] window=%d, dalikey=%d", window, daliKey); - - { - try { - ret = Dali::KeyGrab::UngrabKeyTopmost(*_win, (Dali::KEY)daliKey); - } CALL_CATCH_EXCEPTION(0); - } - - - LOG("CSharp_Dali_UngrabKeyTopmost() [DP2] ret=%d", ret); - - return ret; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GrabKey(void * window, int daliKey, int grabMode) -{ - Dali::Window *_win = (Dali::Window *)window; - bool ret; - - LOG("CSharp_Dali_GrabKey() [DP1] window=%d, dalikey=%d, grabmode=%d", window, daliKey, grabMode); - - { - try { - ret = Dali::KeyGrab::GrabKey(*_win, (Dali::KEY)daliKey, (Dali::KeyGrab::KeyGrabMode)grabMode); - } CALL_CATCH_EXCEPTION(0); - } - - - DALI_LOG_ERROR("CSharp_Dali_GrabKey() [DP2] ret=%d", ret); - - return ret; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_UngrabKey(void * window, int daliKey) -{ - Dali::Window *_win = (Dali::Window *)window; - bool ret; - - LOG("CSharp_Dali_UngrabKey() [DP1] window=%d, dalikey=%d", window, daliKey); - - { - try { - ret = Dali::KeyGrab::UngrabKey(*_win, (Dali::KEY)daliKey); - } CALL_CATCH_EXCEPTION(0); - } - - - LOG("CSharp_Dali_UngrabKey() [DP2] ret=%d", ret); - - return ret; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetNativeWindowHandler( void* window ) -{ - Dali::Window *_win = (Dali::Window *)window; - void * ret = NULL; - - LOG("CSharp_Dali_GetNativeWindowHandler() [DP1] window=%d", window); - - { - Dali::Any result; - try { - result = _win->GetNativeHandle(); -#ifdef TIZEN_BUILD -#ifdef ECORE_WL2 - Ecore_Wl2_Window * ecore_win = Dali::AnyCast(result); -#else - Ecore_Wl_Window * ecore_win = Dali::AnyCast(result); -#endif -#endif - ret = (void*)ecore_win; - - } CALL_CATCH_EXCEPTION(NULL); - } - - if(ret != NULL) - { - LOG("CSharp_Dali_GetNativeWindowHandler() [DP2] ret=%d", ret); - } - - return ret; -} - - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/keyboard-focus-manager-wrap.cpp b/dali-csharp-binder/src/keyboard-focus-manager-wrap.cpp deleted file mode 100755 index 1e98245e..00000000 --- a/dali-csharp-binder/src/keyboard-focus-manager-wrap.cpp +++ /dev/null @@ -1,587 +0,0 @@ -/* - * 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -SWIGINTERN bool Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Empty(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > const *self){ - return self->Empty(); - } -SWIGINTERN std::size_t Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__GetConnectionCount(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > const *self){ - return self->GetConnectionCount(); - } -SWIGINTERN void Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Connect(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *self,Dali::Actor (*func)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)){ - return self->Connect( func ); - } -SWIGINTERN void Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Disconnect(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *self,Dali::Actor (*func)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)){ - self->Disconnect( func ); - } -SWIGINTERN Dali::Actor Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Emit(Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *self,Dali::Actor arg1,Dali::Actor arg2,Dali::Toolkit::Control::KeyboardFocus::Direction arg3){ - return self->Emit( arg1, arg2, arg3 ); - } - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_KeyboardFocusManager() { - void * jresult; - Dali::Toolkit::KeyboardFocusManager *result = 0 ; - - { - try { - result = (Dali::Toolkit::KeyboardFocusManager *)new Dali::Toolkit::KeyboardFocusManager(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_delete_KeyboardFocusManager(void * jarg1) { - Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; - - arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_Get() { - void * jresult; - Dali::Toolkit::KeyboardFocusManager result; - - { - try { - result = Dali::Toolkit::KeyboardFocusManager::Get(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::KeyboardFocusManager((const Dali::Toolkit::KeyboardFocusManager &)result); - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_SetCurrentFocusActor(void * jarg1, void * jarg2) { - unsigned int jresult ; - Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; - Dali::Actor arg2; - Dali::Actor *argp2 ; - bool result; - - arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (bool)(arg1)->SetCurrentFocusActor(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_GetCurrentFocusActor(void * jarg1) { - void * jresult ; - Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; - Dali::Actor result; - - arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; - { - try { - result = (arg1)->GetCurrentFocusActor(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_MoveFocus(void * jarg1, int jarg2) { - unsigned int jresult ; - Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; - Dali::Toolkit::Control::KeyboardFocus::Direction arg2; - bool result; - - arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; - arg2 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg2; - { - try { - result = (bool)(arg1)->MoveFocus(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_ClearFocus(void * jarg1) { - Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; - - arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; - { - try { - (arg1)->ClearFocus(); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_SetFocusGroupLoop(void * jarg1, unsigned int jarg2) { - Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0; - bool arg2; - - arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - (arg1)->SetFocusGroupLoop(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_GetFocusGroupLoop(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; - { - try { - result = (bool)((Dali::Toolkit::KeyboardFocusManager const *)arg1)->GetFocusGroupLoop(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_SetAsFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) { - Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; - Dali::Actor arg2 ; - bool arg3 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - arg3 = jarg3 ? true : false; - { - try { - (arg1)->SetAsFocusGroup(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardFocusManager_IsFocusGroup(void * jarg1, void * jarg2) { - unsigned int jresult ; - Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - bool result; - - arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (bool)((Dali::Toolkit::KeyboardFocusManager const *)arg1)->IsFocusGroup(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_GetFocusGroup(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - Dali::Actor result; - - arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg2 = *argp2; - { - try { - result = (arg1)->GetFocusGroup(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) { - Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetFocusIndicatorActor(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_GetFocusIndicatorActor(void * jarg1) { - void * jresult ; - Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; - Dali::Actor result; - - arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; - { - try { - result = (arg1)->GetFocusIndicatorActor(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_MoveFocusBackward(void * jarg1) { - Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; - - arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; - { - try { - (arg1)->MoveFocusBackward(); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardFocusManager_EnableFocusIndicator(void * manager, bool enable) { - if (!manager) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0); - return ; - } - { - try { - Dali::Toolkit::DevelKeyboardFocusManager::EnableFocusIndicator(*(Dali::Toolkit::KeyboardFocusManager *)manager, enable); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT bool SWIGSTDCALL CSharp_KeyboardFocusManager_IsFocusIndicatorEnabled(void * manager) { - bool result; - if (!manager) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0); - return 0; - } - { - try { - result = Dali::Toolkit::DevelKeyboardFocusManager::IsFocusIndicatorEnabled(*(Dali::Toolkit::KeyboardFocusManager *)manager); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_PreFocusChangeSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; - Dali::Toolkit::KeyboardFocusManager::PreFocusChangeSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; - { - try { - result = (Dali::Toolkit::KeyboardFocusManager::PreFocusChangeSignalType *) &(arg1)->PreFocusChangeSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_FocusChangedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; - Dali::Toolkit::KeyboardFocusManager::FocusChangedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; - { - try { - result = (Dali::Toolkit::KeyboardFocusManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_FocusGroupChangedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::KeyboardFocusManager *arg1 = (Dali::Toolkit::KeyboardFocusManager *) 0 ; - Dali::Toolkit::KeyboardFocusManager::FocusGroupChangedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::KeyboardFocusManager *)jarg1; - { - try { - result = (Dali::Toolkit::KeyboardFocusManager::FocusGroupChangedSignalType *) &(arg1)->FocusGroupChangedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -GENERATE_SIGNAL(Dali::Toolkit::KeyboardFocusManager*, void(*)(Dali::Actor), KeyboardFocusManager, FocusedActorEnterKeySignal) -// CSharp_KeyboardFocusManager_FocusedActorEnterKeySignal_Connect -// CSharp_KeyboardFocusManager_FocusedActorEnterKeySignal_Disconnect - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Empty((Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1; - { - try { - result = Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__GetConnectionCount((Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - -typedef Dali::Actor* (SWIGSTDCALL* SWIG_CallbackKbPreFocusChange)(Dali::Actor *, Dali::Actor *, int); -SWIG_CallbackKbPreFocusChange swig_callbackOnKbPreFocusChange; - -Dali::Actor OnKbPreFocusChangeCallback(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) -{ - Dali::Actor *actorp; - Dali::Actor actor; - Dali::Actor *CurrentP = NULL; - Dali::Actor *ProposedP = NULL; - - if (current) - { - CurrentP = (Dali::Actor *)¤t; - } - - if (proposed) - { - ProposedP = (Dali::Actor *)&proposed; - } - - actorp = (Dali::Actor *)swig_callbackOnKbPreFocusChange(CurrentP, ProposedP, direction); - if (actorp) - { - actor = *actorp; - } - - return actor; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Connect(void * jarg1, SWIG_CallbackKbPreFocusChange callbackOnKbPreFocusChange) { - - swig_callbackOnKbPreFocusChange = callbackOnKbPreFocusChange; - - Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ; - Dali::Actor (*arg2)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)) 0 ; - - arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1; - arg2 = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction))OnKbPreFocusChangeCallback; - - { - try { - Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Disconnect(void * jarg1, SWIG_CallbackKbPreFocusChange callbackOnKbPreFocusChange) { - - swig_callbackOnKbPreFocusChange = callbackOnKbPreFocusChange; - - Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ; - Dali::Actor (*arg2)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction)) 0 ; - - arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1; - arg2 = (Dali::Actor (*)(Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction))OnKbPreFocusChangeCallback; - { - try { - Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardPreFocusChangeSignal_Emit(void * jarg1, void * jarg2, void * jarg3, int jarg4) { - void * jresult ; - Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ; - Dali::Actor arg2 ; - Dali::Actor arg3 ; - Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ; - Dali::Actor *argp2 ; - Dali::Actor *argp3 ; - Dali::Actor result; - - arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg2 = *argp2; - argp3 = (Dali::Actor *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return 0; - } - arg3 = *argp3; - arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4; - { - try { - result = Dali_Signal_Sl_Dali_Actor_Sp_Dali_Actor_Sc_Dali_Actor_Sc_Dali_Toolkit_Control_KeyboardFocus_Direction_SP__Sg__Emit(arg1,arg2,arg3,arg4); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_KeyboardFocusManager_GetNearestFocusableActor(void * jarg1, void * jarg2, Dali::Toolkit::Control::KeyboardFocus::Direction direction) { - void * jresult; - Dali::Actor *argp1 = (Dali::Actor *)jarg1; - Dali::Actor *argp2 = (Dali::Actor *)jarg2; - Dali::Actor rootActor; - Dali::Actor currentFocusedActor; - if (argp1) { - rootActor = *argp1; - } - if (argp2) { - currentFocusedActor = *argp2; - } - Dali::Actor result; - { - try { - result = Dali::Toolkit::FocusFinder::GetNearestFocusableActor(rootActor, currentFocusedActor, direction); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Actor((const Dali::Actor &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_new_KeyboardPreFocusChangeSignal() { - void * jresult ; - Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *result = 0 ; - - { - try { - result = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)new Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_delete_KeyboardPreFocusChangeSignal(void * jarg1) { - Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *) 0 ; - - arg1 = (Dali::Signal< Dali::Actor (Dali::Actor,Dali::Actor,Dali::Toolkit::Control::KeyboardFocus::Direction) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_KeyboardFocusManager_SWIGUpcast(Dali::Toolkit::KeyboardFocusManager *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/keyboard-wrap.cpp b/dali-csharp-binder/src/keyboard-wrap.cpp deleted file mode 100755 index de3cde70..00000000 --- a/dali-csharp-binder/src/keyboard-wrap.cpp +++ /dev/null @@ -1,84 +0,0 @@ -/* - * Copyright (c) 2018 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef TIZEN_BUILD -#ifdef ECORE_WL2 -#include -#else -#include -#endif -#endif - -#undef LOG -//#define LOG DALI_LOG_ERROR -#define LOG(a...) - - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Keyboard_SetRepeatInfo(float rate, float delay) -{ - bool ret; - - LOG("CSharp_Dali_Keyboard_SetRepeatInfo() [DP1] rate=%f, delay=%f", rate, delay); - - { - try { - ret = Dali::Keyboard::SetRepeatInfo(rate, delay); - } CALL_CATCH_EXCEPTION(0); - } - - - LOG("CSharp_Dali_Keyboard_SetRepeatInfo() [DP2] ret=%d", ret); - - return ret; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Keyboard_GetRepeatInfo(float& rate, float& delay) -{ - bool ret; - - LOG("CSharp_Dali_Keyboard_GetRepeatInfo() [DP1] rate=%f, delay=%f", rate, delay); - - { - try { - ret = Dali::Keyboard::GetRepeatInfo(rate, delay); - } CALL_CATCH_EXCEPTION(0); - } - - - LOG("CSharp_Dali_Keyboard_GetRepeatInfo() [DP2] ret=%d", ret); - - return ret; -} - - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/layer-wrap.cpp b/dali-csharp-binder/src/layer-wrap.cpp deleted file mode 100644 index ed7ad74d..00000000 --- a/dali-csharp-binder/src/layer-wrap.cpp +++ /dev/null @@ -1,652 +0,0 @@ -/* - * Copyright (c) 2023 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -using namespace Dali; - -#ifdef __cplusplus -extern "C" { -#endif - -// Property - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() -{ - int jresult; - int result; - - result = (int)Dali::Layer::Property::CLIPPING_ENABLE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() -{ - int jresult; - int result; - - result = (int)Dali::Layer::Property::CLIPPING_BOX; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() -{ - int jresult; - int result; - - result = (int)Dali::Layer::Property::BEHAVIOR; - jresult = (int)result; - return jresult; -} - -// Creation - -SWIGEXPORT Dali::Actor* SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer* jarg1) -{ - return (Dali::Actor*)jarg1; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Layer_Property() -{ - void* jresult; - Dali::Layer::Property* result = 0; - - { - try - { - result = (Dali::Layer::Property*)new Dali::Layer::Property(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void* jarg1) -{ - Dali::Layer::Property* arg1 = (Dali::Layer::Property*)0; - - arg1 = (Dali::Layer::Property*)jarg1; - { - try - { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() -{ - void* jresult; - Dali::Layer* result = 0; - - { - try - { - result = (Dali::Layer*)new Dali::Layer(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Layer_New() -{ - void* jresult; - Dali::Layer result; - - { - try - { - result = Dali::Layer::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Layer((const Dali::Layer&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Layer_DownCast(void* jarg1) -{ - void* jresult; - Dali::BaseHandle arg1; - Dali::BaseHandle* argp1; - Dali::Layer 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::Layer::DownCast(arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Layer((const Dali::Layer&)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void* jarg1) -{ - Dali::Layer* arg1 = (Dali::Layer*)0; - - arg1 = (Dali::Layer*)jarg1; - { - try - { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void* jarg1) -{ - void* jresult; - Dali::Layer* arg1 = 0; - Dali::Layer* result = 0; - - arg1 = (Dali::Layer*)jarg1; - if(!arg1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Layer*)new Dali::Layer((Dali::Layer const&)*arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Layer_Assign(void* jarg1, void* jarg2) -{ - void* jresult; - Dali::Layer* arg1 = (Dali::Layer*)0; - Dali::Layer* arg2 = 0; - Dali::Layer* result = 0; - - arg1 = (Dali::Layer*)jarg1; - arg2 = (Dali::Layer*)jarg2; - if(!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Layer*)&(arg1)->operator=((Dali::Layer const&)*arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -// Method - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void* jarg1) -{ - unsigned int jresult; - Dali::Layer* arg1 = (Dali::Layer*)0; - unsigned int result; - - arg1 = (Dali::Layer*)jarg1; - { - try - { - result = (unsigned int)((Dali::Layer const*)arg1)->GetProperty(Layer::Property::DEPTH); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void* jarg1) -{ - Dali::Layer* arg1 = (Dali::Layer*)0; - - arg1 = (Dali::Layer*)jarg1; - { - try - { - (arg1)->Raise(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void* jarg1) -{ - Dali::Layer* arg1 = (Dali::Layer*)0; - - arg1 = (Dali::Layer*)jarg1; - { - try - { - (arg1)->Lower(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void* jarg1, void* jarg2) -{ - Dali::Layer* arg1 = (Dali::Layer*)0; - Dali::Layer arg2; - Dali::Layer* argp2; - - arg1 = (Dali::Layer*)jarg1; - argp2 = (Dali::Layer*)jarg2; - if(!argp2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0); - return; - } - arg2 = *argp2; - { - try - { - (arg1)->RaiseAbove(arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void* jarg1, void* jarg2) -{ - Dali::Layer* arg1 = (Dali::Layer*)0; - Dali::Layer arg2; - Dali::Layer* argp2; - - arg1 = (Dali::Layer*)jarg1; - argp2 = (Dali::Layer*)jarg2; - if(!argp2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0); - return; - } - arg2 = *argp2; - { - try - { - (arg1)->LowerBelow(arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void* jarg1) -{ - Dali::Layer* arg1 = (Dali::Layer*)0; - - arg1 = (Dali::Layer*)jarg1; - { - try - { - (arg1)->RaiseToTop(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void* jarg1) -{ - Dali::Layer* arg1 = (Dali::Layer*)0; - - arg1 = (Dali::Layer*)jarg1; - { - try - { - (arg1)->LowerToBottom(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void* jarg1, void* jarg2) -{ - Dali::Layer* arg1 = (Dali::Layer*)0; - Dali::Layer arg2; - Dali::Layer* argp2; - - arg1 = (Dali::Layer*)jarg1; - argp2 = (Dali::Layer*)jarg2; - if(!argp2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0); - return; - } - arg2 = *argp2; - { - try - { - (arg1)->MoveAbove(arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void* jarg1, void* jarg2) -{ - Dali::Layer* arg1 = (Dali::Layer*)0; - Dali::Layer arg2; - Dali::Layer* argp2; - - arg1 = (Dali::Layer*)jarg1; - argp2 = (Dali::Layer*)jarg2; - if(!argp2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0); - return; - } - arg2 = *argp2; - { - try - { - (arg1)->MoveBelow(arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void* jarg1, int jarg2) -{ - Dali::Layer* arg1 = (Dali::Layer*)0; - Dali::Layer::Behavior arg2; - - arg1 = (Dali::Layer*)jarg1; - arg2 = (Dali::Layer::Behavior)jarg2; - { - try - { - (arg1)->SetProperty(Layer::Property::BEHAVIOR, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void* jarg1) -{ - int jresult; - Dali::Layer* arg1 = (Dali::Layer*)0; - Dali::Layer::Behavior result; - - arg1 = (Dali::Layer*)jarg1; - { - try - { - result = (Dali::Layer::Behavior)((Dali::Layer const*)arg1)->GetProperty(Dali::Layer::Property::BEHAVIOR); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void* jarg1, bool jarg2) -{ - Dali::Layer* arg1 = (Dali::Layer*)0; - bool arg2; - - arg1 = (Dali::Layer*)jarg1; - arg2 = jarg2 ? true : false; - { - try - { - (arg1)->SetProperty(Dali::Layer::Property::CLIPPING_ENABLE, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void* jarg1) -{ - bool jresult; - Dali::Layer* arg1 = (Dali::Layer*)0; - bool result; - - arg1 = (Dali::Layer*)jarg1; - { - try - { - result = (bool)((Dali::Layer const*)arg1)->GetProperty(Dali::Layer::Property::CLIPPING_ENABLE); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void* jarg1, int jarg2, int jarg3, int jarg4, int jarg5) -{ - Dali::Layer* arg1 = (Dali::Layer*)0; - int arg2; - int arg3; - int arg4; - int arg5; - - arg1 = (Dali::Layer*)jarg1; - arg2 = (int)jarg2; - arg3 = (int)jarg3; - arg4 = (int)jarg4; - arg5 = (int)jarg5; - { - try - { - (arg1)->SetProperty(Dali::Layer::Property::CLIPPING_BOX, Rect(arg2, arg3, arg4, arg5)); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void* jarg1, void* jarg2) -{ - Dali::Layer* arg1 = (Dali::Layer*)0; - Dali::ClippingBox arg2; - Dali::ClippingBox* argp2; - - arg1 = (Dali::Layer*)jarg1; - argp2 = (Dali::ClippingBox*)jarg2; - if(!argp2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0); - return; - } - arg2 = *argp2; - { - try - { - (arg1)->SetProperty(Dali::Layer::Property::CLIPPING_BOX, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void* jarg1) -{ - void* jresult; - Dali::Layer* arg1 = (Dali::Layer*)0; - Dali::ClippingBox result; - - arg1 = (Dali::Layer*)jarg1; - { - try - { - result = ((Dali::Layer const*)arg1)->GetProperty >(Layer::Property::CLIPPING_BOX); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::ClippingBox((const Dali::ClippingBox&)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void* jarg1, bool jarg2) -{ - Dali::Layer* arg1 = (Dali::Layer*)0; - bool arg2; - - arg1 = (Dali::Layer*)jarg1; - arg2 = jarg2 ? true : false; - { - try - { - (arg1)->SetProperty(Layer::Property::DEPTH_TEST, !arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void* jarg1) -{ - bool jresult; - Dali::Layer* arg1 = (Dali::Layer*)0; - bool result; - - arg1 = (Dali::Layer*)jarg1; - { - try - { - result = !(bool)((Dali::Layer const*)arg1)->GetProperty(Layer::Property::DEPTH_TEST); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void* jarg1, void* jarg2) -{ - Dali::Layer* arg1 = (Dali::Layer*)0; - Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType)0; - - arg1 = (Dali::Layer*)jarg1; - arg2 = (Dali::Layer::SortFunctionType)jarg2; - { - try - { - (arg1)->SetSortFunction(arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void* jarg1, bool jarg2) -{ - Dali::Layer* arg1 = (Dali::Layer*)0; - bool arg2; - - arg1 = (Dali::Layer*)jarg1; - arg2 = jarg2 ? true : false; - { - try - { - (arg1)->SetProperty(Layer::Property::CONSUMES_TOUCH, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void* jarg1) -{ - bool jresult; - Dali::Layer* arg1 = (Dali::Layer*)0; - bool result; - - arg1 = (Dali::Layer*)jarg1; - { - try - { - result = (bool)((Dali::Layer const*)arg1)->GetProperty(Layer::Property::CONSUMES_TOUCH); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void* jarg1, bool jarg2) -{ - Dali::Layer* arg1 = (Dali::Layer*)0; - bool arg2; - - arg1 = (Dali::Layer*)jarg1; - arg2 = jarg2 ? true : false; - { - try - { - (arg1)->SetProperty(Layer::Property::CONSUMES_HOVER, arg2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void* jarg1) -{ - bool jresult; - Dali::Layer* arg1 = (Dali::Layer*)0; - bool result; - - arg1 = (Dali::Layer*)jarg1; - { - try - { - result = (bool)((Dali::Layer const*)arg1)->GetProperty(Layer::Property::CONSUMES_HOVER); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/light-wrap.cpp b/dali-csharp-binder/src/light-wrap.cpp deleted file mode 100644 index 858cabd3..00000000 --- a/dali-csharp-binder/src/light-wrap.cpp +++ /dev/null @@ -1,184 +0,0 @@ -/* - * Copyright (c) 2023 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Light_New_SWIG_0() -{ - Dali::Scene3D::Light result; - - { - try - { - result = Dali::Scene3D::Light::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::Light((const Dali::Scene3D::Light&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Light_SWIG_0() -{ - Dali::Scene3D::Light* result = 0; - - { - try - { - result = (Dali::Scene3D::Light*)new Dali::Scene3D::Light(); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Light_SWIG_1(void* csLight) -{ - Dali::Scene3D::Light* light = (Dali::Scene3D::Light*)csLight; - Dali::Scene3D::Light* result = 0; - - if(!light) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::Light const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::Light*)new Dali::Scene3D::Light((Dali::Scene3D::Light const&)*light); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Light(void* csLight) -{ - Dali::Scene3D::Light* light = (Dali::Scene3D::Light*)csLight; - { - try - { - delete light; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Light_Assign(void* csDestination, void* csSource) -{ - Dali::Scene3D::Light* destination = (Dali::Scene3D::Light*)csDestination; - Dali::Scene3D::Light* source = (Dali::Scene3D::Light*)csSource; - Dali::Scene3D::Light* result = 0; - - if(!source) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::Light const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::Light*)&(destination)->operator=((Dali::Scene3D::Light const&)*source); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Light_DownCast(void* csHandle) -{ - Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; - Dali::Scene3D::Light result; - - if(!handle) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Light", 0); - return 0; - } - { - try - { - result = Dali::Scene3D::Light::DownCast(*handle); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::Light((const Dali::Scene3D::Light&)result); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Light_Enable(void* csLight, bool enable) -{ - Dali::Scene3D::Light* light = (Dali::Scene3D::Light*)csLight; - - if(!light) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Light", 0); - return; - } - - try - { - light->Enable(enable); - } - CALL_CATCH_EXCEPTION(); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Light_IsEnabled(void* csLight) -{ - Dali::Scene3D::Light* light = (Dali::Scene3D::Light*)csLight; - bool result; - - if(!light) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Light", 0); - return false; - } - - try - { - result = light->IsEnabled(); - } - CALL_CATCH_EXCEPTION(0); - - return result; -} - -SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_SceneView_GetMaximumEnabledLightCount() -{ - uint32_t result = 0u; - try - { - result = static_cast(Dali::Scene3D::Light::GetMaximumEnabledLightCount()); - } - CALL_CATCH_EXCEPTION(0); - return result; -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/material-wrap.cpp b/dali-csharp-binder/src/material-wrap.cpp deleted file mode 100644 index 6fab1e3b..00000000 --- a/dali-csharp-binder/src/material-wrap.cpp +++ /dev/null @@ -1,358 +0,0 @@ -/* - * Copyright (c) 2023 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Material_New_SWIG_0() -{ - Dali::Scene3D::Material result; - - { - try - { - result = Dali::Scene3D::Material::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::Material((const Dali::Scene3D::Material&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Material_SWIG_0() -{ - Dali::Scene3D::Material* result = 0; - - { - try - { - result = (Dali::Scene3D::Material*)new Dali::Scene3D::Material(); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Material_SWIG_1(void* csModel) -{ - Dali::Scene3D::Material* model = (Dali::Scene3D::Material*)csModel; - Dali::Scene3D::Material* result = 0; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::Material const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::Material*)new Dali::Scene3D::Material((Dali::Scene3D::Material const&)*model); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Material(void* csModel) -{ - Dali::Scene3D::Material* model = (Dali::Scene3D::Material*)csModel; - { - try - { - delete model; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Material_Assign(void* csDestination, void* csSource) -{ - Dali::Scene3D::Material* destination = (Dali::Scene3D::Material*)csDestination; - Dali::Scene3D::Material* source = (Dali::Scene3D::Material*)csSource; - Dali::Scene3D::Material* result = 0; - - if(!source) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::Material const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::Material*)&(destination)->operator=((Dali::Scene3D::Material const&)*source); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Material_DownCast(void* csHandle) -{ - Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; - Dali::Scene3D::Material result; - - if(!handle) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Material", 0); - return 0; - } - { - try - { - result = Dali::Scene3D::Material::DownCast(*handle); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::Material((const Dali::Scene3D::Material&)result); -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_NAME_get() -{ - return (int)Dali::Scene3D::Material::Property::NAME; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_BASE_COLOR_URL_get() -{ - return (int)Dali::Scene3D::Material::Property::BASE_COLOR_URL; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_BASE_COLOR_FACTOR_get() -{ - return (int)Dali::Scene3D::Material::Property::BASE_COLOR_FACTOR; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_METALLIC_ROUGHNESS_URL_get() -{ - return (int)Dali::Scene3D::Material::Property::METALLIC_ROUGHNESS_URL; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_METALLIC_FACTOR_get() -{ - return (int)Dali::Scene3D::Material::Property::METALLIC_FACTOR; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_ROUGHNESS_FACTOR_get() -{ - return (int)Dali::Scene3D::Material::Property::ROUGHNESS_FACTOR; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_NORMAL_URL_get() -{ - return (int)Dali::Scene3D::Material::Property::NORMAL_URL; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_NORMAL_SCALE_get() -{ - return (int)Dali::Scene3D::Material::Property::NORMAL_SCALE; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_OCCLUSION_URL_get() -{ - return (int)Dali::Scene3D::Material::Property::OCCLUSION_URL; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_OCCLUSION_STRENGTH_get() -{ - return (int)Dali::Scene3D::Material::Property::OCCLUSION_STRENGTH; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_EMISSIVE_URL_get() -{ - return (int)Dali::Scene3D::Material::Property::EMISSIVE_URL; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_EMISSIVE_FACTOR_get() -{ - return (int)Dali::Scene3D::Material::Property::EMISSIVE_FACTOR; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_ALPHA_MODE_get() -{ - return (int)Dali::Scene3D::Material::Property::ALPHA_MODE; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_ALPHA_CUTOFF_get() -{ - return (int)Dali::Scene3D::Material::Property::ALPHA_CUTOFF; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_DOUBLE_SIDED_get() -{ - return (int)Dali::Scene3D::Material::Property::DOUBLE_SIDED; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_IOR_get() -{ - return (int)Dali::Scene3D::Material::Property::IOR; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_SPECULAR_URL_get() -{ - return (int)Dali::Scene3D::Material::Property::SPECULAR_URL; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_SPECULAR_FACTOR_get() -{ - return (int)Dali::Scene3D::Material::Property::SPECULAR_FACTOR; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_SPECULAR_COLOR_URL_get() -{ - return (int)Dali::Scene3D::Material::Property::SPECULAR_COLOR_URL; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Material_property_SPECULAR_COLOR_FACTOR_get() -{ - return (int)Dali::Scene3D::Material::Property::SPECULAR_COLOR_FACTOR; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Material_SetProperty(void* csMaterial, int index, void* csPropertyValue) -{ - Dali::Scene3D::Material* material = (Dali::Scene3D::Material*)csMaterial; - Dali::Property::Value* propertyValue = (Dali::Property::Value*)csPropertyValue; - - if(!material) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Material", 0); - return; - } - { - try - { - material->SetProperty((Dali::Property::Index)index, *propertyValue); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Material_GetProperty(void* csMaterial, int index) -{ - Dali::Scene3D::Material* material = (Dali::Scene3D::Material*)csMaterial; - Dali::Property::Value result; - - if(!material) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Material", 0); - return nullptr; - } - { - try - { - result = material->GetProperty((Dali::Property::Index)index); - } - CALL_CATCH_EXCEPTION(nullptr); - } - return new Dali::Property::Value((const Dali::Property::Value&)result); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Material_SetTexture(void* csMaterial, unsigned int index, void* csTexture) -{ - Dali::Scene3D::Material* material = (Dali::Scene3D::Material*)csMaterial; - Dali::Texture* texture = (Dali::Texture*)csTexture; - - if(!material) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Material", 0); - return; - } - - if(!texture) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0); - return; - } - - try - { - material->SetTexture((Dali::Scene3D::Material::TextureType)index, *texture); - } - CALL_CATCH_EXCEPTION(); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Material_GetTexture(void* csMaterial, unsigned int index) -{ - Dali::Scene3D::Material* material = (Dali::Scene3D::Material*)csMaterial; - Dali::Texture result; - - if(!material) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Material", 0); - return nullptr; - } - - try - { - result = material->GetTexture((Dali::Scene3D::Material::TextureType)index); - } - CALL_CATCH_EXCEPTION(nullptr); - - return new Dali::Texture((const Dali::Texture&)result); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Material_SetSampler(void* csMaterial, unsigned int index, void* csSampler) -{ - Dali::Scene3D::Material* material = (Dali::Scene3D::Material*)csMaterial; - Dali::Sampler* sampler = (Dali::Sampler*)csSampler; - - if(!material) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Material", 0); - return; - } - - try - { - material->SetSampler((Dali::Scene3D::Material::TextureType)index, *sampler); - } - CALL_CATCH_EXCEPTION(); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Material_GetSampler(void* csMaterial, unsigned int index) -{ - Dali::Scene3D::Material* material = (Dali::Scene3D::Material*)csMaterial; - Dali::Sampler result; - - if(!material) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Material", 0); - return nullptr; - } - - try - { - result = material->GetSampler((Dali::Scene3D::Material::TextureType)index); - } - CALL_CATCH_EXCEPTION(nullptr); - return new Dali::Sampler((const Dali::Sampler&)result); -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/model-node-wrap.cpp b/dali-csharp-binder/src/model-node-wrap.cpp deleted file mode 100644 index fb289a61..00000000 --- a/dali-csharp-binder/src/model-node-wrap.cpp +++ /dev/null @@ -1,259 +0,0 @@ -/* - * Copyright (c) 2023 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Node_New_SWIG_0() -{ - Dali::Scene3D::ModelNode result; - { - try - { - result = Dali::Scene3D::ModelNode::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::ModelNode((const Dali::Scene3D::ModelNode&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Model_Node_SWIG_0() -{ - Dali::Scene3D::ModelNode* result = 0; - - { - try - { - result = (Dali::Scene3D::ModelNode*)new Dali::Scene3D::ModelNode(); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Model_Node_SWIG_1(void* csModel) -{ - Dali::Scene3D::ModelNode* model = (Dali::Scene3D::ModelNode*)csModel; - Dali::Scene3D::ModelNode* result = 0; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::ModelNode const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::ModelNode*)new Dali::Scene3D::ModelNode((Dali::Scene3D::ModelNode const&)*model); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model_Node(void* csModel) -{ - Dali::Scene3D::ModelNode* model = (Dali::Scene3D::ModelNode*)csModel; - { - try - { - delete model; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Node_Assign(void* csDestination, void* csSource) -{ - Dali::Scene3D::ModelNode* destination = (Dali::Scene3D::ModelNode*)csDestination; - Dali::Scene3D::ModelNode* source = (Dali::Scene3D::ModelNode*)csSource; - Dali::Scene3D::ModelNode* result = 0; - - if(!source) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::ModelNode const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::ModelNode*)&(destination)->operator=((Dali::Scene3D::ModelNode const&)*source); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Node_DownCast(void* csHandle) -{ - Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; - Dali::Scene3D::ModelNode result; - - if(!handle) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelNode", 0); - return 0; - } - { - try - { - result = Dali::Scene3D::ModelNode::DownCast(*handle); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::ModelNode((const Dali::Scene3D::ModelNode&)result); -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Model_Node_GetModelPrimitiveCount(void* csModelNode) -{ - Dali::Scene3D::ModelNode* modelNode = (Dali::Scene3D::ModelNode*)csModelNode; - - if(!modelNode) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelNode", 0); - return 0; - } - { - try - { - return modelNode->GetModelPrimitiveCount(); - } - CALL_CATCH_EXCEPTION(0); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_Node_AddModelPrimitive(void* csModelNode, void* csModelPrimitive) -{ - Dali::Scene3D::ModelNode* modelNode = (Dali::Scene3D::ModelNode*)csModelNode; - Dali::Scene3D::ModelPrimitive* modelPrimitive = (Dali::Scene3D::ModelPrimitive*)csModelPrimitive; - - if(!modelNode) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelNode", 0); - return; - } - if(!modelPrimitive) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelPrimitive", 0); - return; - } - { - try - { - modelNode->AddModelPrimitive(*modelPrimitive); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_Node_RemoveModelPrimitive1(void* csModelNode, void* csModelPrimitive) -{ - Dali::Scene3D::ModelNode* modelNode = (Dali::Scene3D::ModelNode*)csModelNode; - Dali::Scene3D::ModelPrimitive* modelPrimitive = (Dali::Scene3D::ModelPrimitive*)csModelPrimitive; - - if(!modelNode) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelNode", 0); - return; - } - if(!modelPrimitive) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelPrimitive", 0); - return; - } - { - try - { - modelNode->RemoveModelPrimitive(*modelPrimitive); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_Node_RemoveModelPrimitive2(void* csModelNode, unsigned int index) -{ - Dali::Scene3D::ModelNode* modelNode = (Dali::Scene3D::ModelNode*)csModelNode; - - if(!modelNode) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelNode", 0); - return; - } - { - try - { - modelNode->RemoveModelPrimitive(index); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Node_GetModelPrimitive(void* csModelNode, unsigned int index) -{ - Dali::Scene3D::ModelNode* modelNode = (Dali::Scene3D::ModelNode*)csModelNode; - Dali::Scene3D::ModelPrimitive result; - - if(!modelNode) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelNode", 0); - return nullptr; - } - { - try - { - result = modelNode->GetModelPrimitive(index); - } - CALL_CATCH_EXCEPTION(nullptr); - } - return new Dali::Scene3D::ModelPrimitive((const Dali::Scene3D::ModelPrimitive&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Node_FindChildModelNodeByName(void* csModelNode, char* nodeName) -{ - Dali::Scene3D::ModelNode* modelNode = (Dali::Scene3D::ModelNode*)csModelNode; - Dali::Scene3D::ModelNode result; - - if(!modelNode) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelNode", 0); - return nullptr; - } - { - try - { - result = modelNode->FindChildModelNodeByName(nodeName); - } - CALL_CATCH_EXCEPTION(nullptr); - } - return new Dali::Scene3D::ModelNode((const Dali::Scene3D::ModelNode&)result); -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/model-primitive-wrap.cpp b/dali-csharp-binder/src/model-primitive-wrap.cpp deleted file mode 100644 index 232b4708..00000000 --- a/dali-csharp-binder/src/model-primitive-wrap.cpp +++ /dev/null @@ -1,194 +0,0 @@ -/* - * Copyright (c) 2023 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Primitive_New_SWIG_0() -{ - Dali::Scene3D::ModelPrimitive result; - - { - try - { - result = Dali::Scene3D::ModelPrimitive::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::ModelPrimitive((const Dali::Scene3D::ModelPrimitive&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Model_Primitive_SWIG_0() -{ - Dali::Scene3D::ModelPrimitive* result = 0; - - { - try - { - result = (Dali::Scene3D::ModelPrimitive*)new Dali::Scene3D::ModelPrimitive(); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Model_Primitive_SWIG_1(void* csModel) -{ - Dali::Scene3D::ModelPrimitive* model = (Dali::Scene3D::ModelPrimitive*)csModel; - Dali::Scene3D::ModelPrimitive* result = 0; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::ModelPrimitive const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::ModelPrimitive*)new Dali::Scene3D::ModelPrimitive((Dali::Scene3D::ModelPrimitive const&)*model); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model_Primitive(void* csModel) -{ - Dali::Scene3D::ModelPrimitive* model = (Dali::Scene3D::ModelPrimitive*)csModel; - { - try - { - delete model; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Primitive_Assign(void* csDestination, void* csSource) -{ - Dali::Scene3D::ModelPrimitive* destination = (Dali::Scene3D::ModelPrimitive*)csDestination; - Dali::Scene3D::ModelPrimitive* source = (Dali::Scene3D::ModelPrimitive*)csSource; - Dali::Scene3D::ModelPrimitive* result = 0; - - if(!source) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::ModelPrimitive const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::ModelPrimitive*)&(destination)->operator=((Dali::Scene3D::ModelPrimitive const&)*source); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Primitive_DownCast(void* csHandle) -{ - Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; - Dali::Scene3D::ModelPrimitive result; - - if(!handle) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelPrimitive", 0); - return 0; - } - { - try - { - result = Dali::Scene3D::ModelPrimitive::DownCast(*handle); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::ModelPrimitive((const Dali::Scene3D::ModelPrimitive&)result); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_Primitive_SetGeometry(void* csModelPrimitive, void* csGeometry) -{ - Dali::Scene3D::ModelPrimitive* modelPrimitive = (Dali::Scene3D::ModelPrimitive*)csModelPrimitive; - Dali::Geometry* geometry = (Dali::Geometry*)csGeometry; - - if(!modelPrimitive) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelPrimitive", 0); - return; - } - { - try - { - modelPrimitive->SetGeometry(*geometry); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Primitive_GetGeometry(void* csModelPrimitive) -{ - Dali::Scene3D::ModelPrimitive* modelPrimitive = (Dali::Scene3D::ModelPrimitive*)csModelPrimitive; - Dali::Geometry result; - - if(!modelPrimitive) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelPrimitive", 0); - return nullptr; - } - { - try - { - result = modelPrimitive->GetGeometry(); - } - CALL_CATCH_EXCEPTION(nullptr); - } - return new Dali::Geometry((const Dali::Geometry&)result); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_Primitive_SetMaterial(void* csModelPrimitive, void* csMaterial) -{ - Dali::Scene3D::ModelPrimitive* modelPrimitive = (Dali::Scene3D::ModelPrimitive*)csModelPrimitive; - Dali::Scene3D::Material* material = (Dali::Scene3D::Material*)csMaterial; - - if(!modelPrimitive) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelNode", 0); - return; - } - - try - { - modelPrimitive->SetMaterial(*material); - } - CALL_CATCH_EXCEPTION(); -} - - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/model-wrap.cpp b/dali-csharp-binder/src/model-wrap.cpp deleted file mode 100644 index b3b254a5..00000000 --- a/dali-csharp-binder/src/model-wrap.cpp +++ /dev/null @@ -1,748 +0,0 @@ -/* - * Copyright (c) 2023 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_New_SWIG_0(char* csModelPath, char* csResourcePath) -{ - Dali::Scene3D::Model result; - - if(!csModelPath) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string modelPath(csModelPath); - - if(!csResourcePath) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string resourcePath(csResourcePath); - - { - try - { - result = Dali::Scene3D::Model::New(modelPath, resourcePath); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::Model((const Dali::Scene3D::Model&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_New_SWIG_1() -{ - Dali::Scene3D::Model result; - - { - try - { - result = Dali::Scene3D::Model::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::Model((const Dali::Scene3D::Model&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Model_SWIG_0() -{ - Dali::Scene3D::Model* result = 0; - - { - try - { - result = (Dali::Scene3D::Model*)new Dali::Scene3D::Model(); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Model_SWIG_1(void* csModel) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - Dali::Scene3D::Model* result = 0; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::Model const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::Model*)new Dali::Scene3D::Model((Dali::Scene3D::Model const&)*model); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model(void* csModel) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - { - try - { - delete model; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_Assign(void* csDestination, void* csSource) -{ - Dali::Scene3D::Model* destination = (Dali::Scene3D::Model*)csDestination; - Dali::Scene3D::Model* source = (Dali::Scene3D::Model*)csSource; - Dali::Scene3D::Model* result = 0; - - if(!source) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::Model const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::Model*)&(destination)->operator=((Dali::Scene3D::Model const&)*source); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_DownCast(void* csHandle) -{ - Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; - Dali::Scene3D::Model result; - - if(!handle) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return 0; - } - { - try - { - result = Dali::Scene3D::Model::DownCast(*handle); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::Model((const Dali::Scene3D::Model&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_GetModelRoot(void* csModel) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - Dali::Scene3D::ModelNode result; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return 0; - } - { - try - { - result = model->GetModelRoot(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::ModelNode((const Dali::Scene3D::ModelNode&)result); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_AddModelNode(void* csModel, void* csModelNode) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - Dali::Scene3D::ModelNode* modelNode = (Dali::Scene3D::ModelNode*)csModelNode; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return; - } - - try - { - model->AddModelNode(*modelNode); - } - CALL_CATCH_EXCEPTION(); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_RemoveModelNode(void* csModel, void* csModelNode) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - Dali::Scene3D::ModelNode* modelNode = (Dali::Scene3D::ModelNode*)csModelNode; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return; - } - - try - { - model->RemoveModelNode(*modelNode); - } - CALL_CATCH_EXCEPTION(); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_SetChildrenSensitive(void* csModel, bool enable) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return; - } - { - try - { - model->SetChildrenSensitive(enable); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Model_GetChildrenSensitive(void* csModel) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - bool result; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return false; - } - { - try - { - result = model->GetChildrenSensitive(); - } - CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_SetImageBasedLightSource(void* csModel, char* csDiffuseUrl, char* csSpecularUrl, float scaleFactor) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return; - } - if(!csDiffuseUrl) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return; - } - std::string diffuseUrl(csDiffuseUrl); - if(!csSpecularUrl) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return; - } - std::string specularUrl(csSpecularUrl); - { - try - { - model->SetImageBasedLightSource(diffuseUrl, specularUrl, scaleFactor); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_SetImageBasedLightScaleFactor(void* csModel, float scaleFactor) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return; - } - { - try - { - model->SetImageBasedLightScaleFactor(scaleFactor); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Model_GetImageBasedLightScaleFactor(void* csModel) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - float scaleFactor = 1.0f; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return scaleFactor; - } - { - try - { - scaleFactor = model->GetImageBasedLightScaleFactor(); - } - CALL_CATCH_EXCEPTION(0.0f); - } - return scaleFactor; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Model_GetAnimationCount(void* csModel) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - unsigned int result; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return 0; - } - { - try - { - result = model->GetAnimationCount(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_GetAnimation_1(void* csModel, unsigned int index) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - Dali::Animation result; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return 0; - } - { - try - { - result = model->GetAnimation(index); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Animation((const Dali::Animation&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_GetAnimation_2(void* csModel, char* csName) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - Dali::Animation result; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return 0; - } - if(!csName) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string name(csName); - { - try - { - result = model->GetAnimation(name); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Animation((const Dali::Animation&)result); -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Model_GetCameraCount(void* csModel) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - unsigned int result; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return 0; - } - { - try - { - result = model->GetCameraCount(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_GenerateCamera(void* csModel, unsigned int index) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - Dali::CameraActor result; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return 0; - } - { - try - { - result = model->GenerateCamera(index); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::CameraActor((const Dali::CameraActor&)result); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Model_ApplyCamera(void* csModel, unsigned int index, void* csCameraActor) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - Dali::CameraActor* cameraActor = (Dali::CameraActor*)csCameraActor; - bool result; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return 0; - } - if(!cameraActor) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0); - return 0; - } - { - try - { - result = model->ApplyCamera(index, *cameraActor); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_FindChildModelNodeByName(void* csModel, char* nodeName) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - Dali::Scene3D::ModelNode result; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return nullptr; - } - - try - { - result = model->FindChildModelNodeByName(std::string_view(nodeName)); - } - CALL_CATCH_EXCEPTION(nullptr); - - return new Dali::Scene3D::ModelNode((const Dali::Scene3D::ModelNode&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_GenerateMotionDataAnimation(void* csModel, void* csMotionData) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; - Dali::Animation result; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return nullptr; - } - if(!motionData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); - return nullptr; - } - - try - { - result = model->GenerateMotionDataAnimation(*motionData); - } - CALL_CATCH_EXCEPTION(nullptr); - - return new Dali::Animation((const Dali::Animation&)result); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Model_SetMotionData(void* csModel, void* csMotionData) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return; - } - if(!motionData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); - return; - } - - try - { - model->SetMotionData(*motionData); - } - CALL_CATCH_EXCEPTION(); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_LoadBvhAnimation_1(void* csModel, char* csFileName, void* csScale, bool csUseRootNodeTranslate) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - Dali::Animation result; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return 0; - } - if(!csFileName) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for filename", 0); - return 0; - } - - Dali::Vector3 scale = Dali::Vector3::ONE; - // csScale is option. - if(csScale != nullptr) - { - scale = Dali::Vector3(*static_cast(csScale)); - } - - std::string filename(csFileName); - { - try - { - Dali::Scene3D::Loader::AnimationDefinition animationDefinition = Dali::Scene3D::Loader::LoadBvh(filename, "LoadedBvhAnimation", scale); - - if(csUseRootNodeTranslate && animationDefinition.GetPropertyCount() > 0u) - { - // We can assume that 0's property is for root translate - auto& property = animationDefinition.GetPropertyAt(0u); - auto& keyFrames = property.mKeyFrames; - - // Let we check that we can change animatable property - // TODO : If AnimateBetweenBy feature prepared, we can remove below logic. - if(keyFrames) - { - auto rootNode = model->FindChildByName(property.mNodeName); - if(rootNode) - { - // Get root node's current position and apply it into property animation. - auto rootNodePosition = rootNode.GetProperty(Dali::Actor::Property::POSITION); - - auto frameCount = Dali::DevelKeyFrames::GetKeyFrameCount(keyFrames); - for(auto i = 0u; i < frameCount; ++i) - { - float keyFrameProgress; - Dali::Property::Value keyFrameValue; - Dali::Vector3 valuePosition; - - Dali::DevelKeyFrames::GetKeyFrame(keyFrames, i, keyFrameProgress, keyFrameValue); - if(DALI_LIKELY(keyFrameValue.Get(valuePosition))) - { - Dali::DevelKeyFrames::SetKeyFrameValue(keyFrames, i, rootNodePosition + valuePosition); - } - } - } - } - } - - Dali::Scene3D::Loader::AnimatedProperty::GetActor getActor = [&model](const Dali::Scene3D::Loader::AnimatedProperty& property) -> Dali::Actor { - return model->FindChildByName(property.mNodeName); - }; - result = animationDefinition.ReAnimate(getActor); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Animation((const Dali::Animation&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_LoadBvhAnimation_2(void* csModel, char* csBuffer, int csBufferLength, void* csScale, bool csUseRootNodeTranslate) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - Dali::Animation result; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return 0; - } - if(!csBuffer) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for buffer", 0); - return 0; - } - - Dali::Vector3 scale = Dali::Vector3::ONE; - // csScale is option. - if(csScale != nullptr) - { - scale = Dali::Vector3(*static_cast(csScale)); - } - - const uint8_t* rawBuffer = reinterpret_cast(csBuffer); - { - try - { - Dali::Scene3D::Loader::AnimationDefinition animationDefinition = Dali::Scene3D::Loader::LoadBvhFromBuffer(rawBuffer, csBufferLength, "LoadedBvhAnimation", scale); - - if(csUseRootNodeTranslate && animationDefinition.GetPropertyCount() > 0u) - { - // We can assume that 0's property is for root translate - auto& property = animationDefinition.GetPropertyAt(0u); - auto& keyFrames = property.mKeyFrames; - - // Let we check that we can change animatable property - // TODO : If AnimateBetweenBy feature prepared, we can remove below logic. - if(keyFrames) - { - auto rootNode = model->FindChildByName(property.mNodeName); - if(rootNode) - { - // Get root node's current position and apply it into property animation. - auto rootNodePosition = rootNode.GetProperty(Dali::Actor::Property::POSITION); - - auto frameCount = Dali::DevelKeyFrames::GetKeyFrameCount(keyFrames); - for(auto i = 0u; i < frameCount; ++i) - { - float keyFrameProgress; - Dali::Property::Value keyFrameValue; - Dali::Vector3 valuePosition; - Dali::DevelKeyFrames::GetKeyFrame(keyFrames, i, keyFrameProgress, keyFrameValue); - if(DALI_LIKELY(keyFrameValue.Get(valuePosition))) - { - Dali::DevelKeyFrames::SetKeyFrameValue(keyFrames, i, rootNodePosition + valuePosition); - } - } - } - } - } - - Dali::Scene3D::Loader::AnimatedProperty::GetActor getActor = [&model](const Dali::Scene3D::Loader::AnimatedProperty& property) -> Dali::Actor { - return model->FindChildByName(property.mNodeName); - }; - result = animationDefinition.ReAnimate(getActor); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Animation((const Dali::Animation&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_LoadFacialAnimation_1(void* csModel, char* csFileName) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - Dali::Animation result; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return 0; - } - if(!csFileName) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for filename", 0); - return 0; - } - - std::string filename(csFileName); - { - try - { - Dali::Scene3D::Loader::AnimationDefinition animationDefinition = Dali::Scene3D::Loader::LoadFacialAnimation(filename); - Dali::Scene3D::Loader::AnimatedProperty::GetActor getActor = [&model](const Dali::Scene3D::Loader::AnimatedProperty& property) -> Dali::Actor { - return model->FindChildByName(property.mNodeName); - }; - result = animationDefinition.ReAnimate(getActor); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Animation((const Dali::Animation&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Model_LoadFacialAnimation_2(void* csModel, char* csBuffer, int csBufferLength) -{ - Dali::Scene3D::Model* model = (Dali::Scene3D::Model*)csModel; - Dali::Animation result; - - if(!model) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return 0; - } - if(!csBuffer) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for buffer", 0); - return 0; - } - - const uint8_t* rawBuffer = reinterpret_cast(csBuffer); - { - try - { - Dali::Scene3D::Loader::AnimationDefinition animationDefinition = Dali::Scene3D::Loader::LoadFacialAnimationFromBuffer(rawBuffer, csBufferLength); - Dali::Scene3D::Loader::AnimatedProperty::GetActor getActor = [&model](const Dali::Scene3D::Loader::AnimatedProperty& property) -> Dali::Actor { - return model->FindChildByName(property.mNodeName); - }; - result = animationDefinition.ReAnimate(getActor); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Animation((const Dali::Animation&)result); -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/motion-data-wrap.cpp b/dali-csharp-binder/src/motion-data-wrap.cpp deleted file mode 100644 index 9b4b68f4..00000000 --- a/dali-csharp-binder/src/motion-data-wrap.cpp +++ /dev/null @@ -1,426 +0,0 @@ -/* - * Copyright (c) 2023 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionData_New_SWIG_0() -{ - Dali::Scene3D::MotionData result; - - { - try - { - result = Dali::Scene3D::MotionData::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::MotionData((const Dali::Scene3D::MotionData&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionData_New_SWIG_1(float durationSeconds) -{ - Dali::Scene3D::MotionData result; - - { - try - { - result = Dali::Scene3D::MotionData::New(durationSeconds); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::MotionData((const Dali::Scene3D::MotionData&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionData_SWIG_0() -{ - Dali::Scene3D::MotionData* result = 0; - - { - try - { - result = (Dali::Scene3D::MotionData*)new Dali::Scene3D::MotionData(); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionData_SWIG_1(void* csMotionData) -{ - Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; - Dali::Scene3D::MotionData* result = 0; - - if(!motionData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionData const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::MotionData*)new Dali::Scene3D::MotionData((Dali::Scene3D::MotionData const&)*motionData); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MotionData(void* csMotionData) -{ - Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; - { - try - { - delete motionData; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionData_Assign(void* csDestination, void* csSource) -{ - Dali::Scene3D::MotionData* destination = (Dali::Scene3D::MotionData*)csDestination; - Dali::Scene3D::MotionData* source = (Dali::Scene3D::MotionData*)csSource; - Dali::Scene3D::MotionData* result = 0; - - if(!source) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionData const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::MotionData*)&(destination)->operator=((Dali::Scene3D::MotionData const&)*source); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionData_DownCast(void* csHandle) -{ - Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; - Dali::Scene3D::MotionData result; - - if(!handle) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return 0; - } - { - try - { - result = Dali::Scene3D::MotionData::DownCast(*handle); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::MotionData((const Dali::Scene3D::MotionData&)result); -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_MotionData_GetMotionCount(void* csMotionData) -{ - Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; - unsigned int result; - - if(!motionData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); - return 0; - } - { - try - { - result = static_cast(motionData->GetMotionCount()); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionData_GetIndex(void* csMotionData, unsigned int index) -{ - Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; - Dali::Scene3D::MotionIndex result; - - if(!motionData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); - return 0; - } - { - try - { - result = motionData->GetIndex(static_cast(index)); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::MotionIndex((const Dali::Scene3D::MotionIndex&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionData_GetValue(void* csMotionData, unsigned int index) -{ - Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; - Dali::Scene3D::MotionValue result; - - if(!motionData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); - return 0; - } - { - try - { - result = motionData->GetValue(static_cast(index)); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::MotionValue((const Dali::Scene3D::MotionValue&)result); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_Add(void* csMotionData, void* csMotionIndex, void* csMotionValue) -{ - Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; - Dali::Scene3D::MotionIndex* motionIndex = (Dali::Scene3D::MotionIndex*)csMotionIndex; - Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue; - - if(!motionData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); - return; - } - if(!motionIndex) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionIndex", 0); - return; - } - if(!motionValue) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0); - return; - } - - { - try - { - motionData->Add(*motionIndex, *motionValue); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_Clear(void* csMotionData) -{ - Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; - - if(!motionData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); - return; - } - - { - try - { - motionData->Clear(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_SetDuration(void* csMotionData, float durationSeconds) -{ - Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; - - if(!motionData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); - return; - } - - { - try - { - motionData->SetDuration(durationSeconds); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MotionData_GetDuration(void* csMotionData) -{ - Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; - float result; - - if(!motionData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); - return 0.0f; - } - - { - try - { - result = motionData->GetDuration(); - } - CALL_CATCH_EXCEPTION(0.0f); - } - - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_LoadBvh(void* csMotionData, char* csFileName, void* csScale, bool csSynchronousLoad) -{ - Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; - - if(!motionData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); - return; - } - if(!csFileName) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for filename", 0); - return; - } - - Dali::Vector3 scale = Dali::Vector3::ONE; - // csScale is option. - if(csScale != nullptr) - { - scale = Dali::Vector3(*static_cast(csScale)); - } - - std::string filename(csFileName); - { - try - { - motionData->LoadBvh(filename, scale, csSynchronousLoad); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_LoadBvhFromBuffer(void* csMotionData, char* csBuffer, int csBufferLength, void* csScale, bool csSynchronousLoad) -{ - Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; - - if(!motionData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); - return; - } - if(!csBuffer) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for buffer", 0); - return; - } - - Dali::Vector3 scale = Dali::Vector3::ONE; - // csScale is option. - if(csScale != nullptr) - { - scale = Dali::Vector3(*static_cast(csScale)); - } - - const uint8_t* rawBuffer = reinterpret_cast(csBuffer); - { - try - { - motionData->LoadBvhFromBuffer(rawBuffer, csBufferLength, scale, csSynchronousLoad); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_LoadFacialAnimation(void* csMotionData, char* csFileName, bool csSynchronousLoad) -{ - Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; - - if(!motionData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); - return; - } - if(!csFileName) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for filename", 0); - return; - } - - std::string filename(csFileName); - { - try - { - motionData->LoadFacialAnimation(filename, csSynchronousLoad); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionData_LoadFacialAnimationFromBuffer(void* csMotionData, char* csBuffer, int csBufferLength, bool csSynchronousLoad) -{ - Dali::Scene3D::MotionData* motionData = (Dali::Scene3D::MotionData*)csMotionData; - - if(!motionData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionData", 0); - return; - } - if(!csBuffer) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string for buffer", 0); - return; - } - - const uint8_t* rawBuffer = reinterpret_cast(csBuffer); - { - try - { - motionData->LoadFacialAnimationFromBuffer(rawBuffer, csBufferLength, csSynchronousLoad); - } - CALL_CATCH_EXCEPTION(); - } -} - -// Signals -GENERATE_SIGNAL(Dali::Scene3D::MotionData*, void(*)(Dali::Scene3D::MotionData), Dali_MotionData, LoadCompletedSignal); -// CSharp_Dali_MotionData_LoadCompletedSignal_Connect -// CSharp_Dali_MotionData_LoadCompletedSignal_Disconnect - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/motion-index-wrap.cpp b/dali-csharp-binder/src/motion-index-wrap.cpp deleted file mode 100644 index 5ec61bc1..00000000 --- a/dali-csharp-binder/src/motion-index-wrap.cpp +++ /dev/null @@ -1,720 +0,0 @@ -/* - * Copyright (c) 2023 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -// MotionIndex - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionIndex_SWIG_0() -{ - Dali::Scene3D::MotionIndex* result = 0; - - { - try - { - result = (Dali::Scene3D::MotionIndex*)new Dali::Scene3D::MotionIndex(); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionIndex_SWIG_1(void* csMotionIndex) -{ - Dali::Scene3D::MotionIndex* motionIndex = (Dali::Scene3D::MotionIndex*)csMotionIndex; - Dali::Scene3D::MotionIndex* result = 0; - - if(!motionIndex) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionIndex const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::MotionIndex*)new Dali::Scene3D::MotionIndex((Dali::Scene3D::MotionIndex const&)*motionIndex); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MotionIndex(void* csMotionIndex) -{ - Dali::Scene3D::MotionIndex* motionIndex = (Dali::Scene3D::MotionIndex*)csMotionIndex; - { - try - { - delete motionIndex; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionIndex_Assign(void* csDestination, void* csSource) -{ - Dali::Scene3D::MotionIndex* destination = (Dali::Scene3D::MotionIndex*)csDestination; - Dali::Scene3D::MotionIndex* source = (Dali::Scene3D::MotionIndex*)csSource; - Dali::Scene3D::MotionIndex* result = 0; - - if(!source) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionIndex const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::MotionIndex*)&(destination)->operator=((Dali::Scene3D::MotionIndex const&)*source); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionIndex_DownCast(void* csHandle) -{ - Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; - Dali::Scene3D::MotionIndex result; - - if(!handle) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return 0; - } - { - try - { - result = Dali::Scene3D::MotionIndex::DownCast(*handle); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::MotionIndex((const Dali::Scene3D::MotionIndex&)result); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionIndex_SetModelNodeId(void* csMotionIndex, void* csPropertyKey) -{ - Dali::Scene3D::MotionIndex* motionIndex = (Dali::Scene3D::MotionIndex*)csMotionIndex; - Dali::Property::Key* propertyKey = (Dali::Property::Key*)csPropertyKey; - - if(!motionIndex) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionIndex", 0); - return; - } - if(!propertyKey) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0); - return; - } - { - try - { - motionIndex->SetModelNodeId(*propertyKey); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionIndex_GetModelNodeId(void* csMotionIndex) -{ - Dali::Scene3D::MotionIndex* motionIndex = (Dali::Scene3D::MotionIndex*)csMotionIndex; - Dali::Property::Key result = Dali::Property::INVALID_KEY; - - if(!motionIndex) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionIndex", 0); - return 0; - } - { - try - { - result = motionIndex->GetModelNodeId(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Property::Key((Dali::Property::Key const &)result); -} - -// BlendShapeIndex - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_BlendShapeIndex_New_SWIG_0() -{ - Dali::Scene3D::BlendShapeIndex result; - - { - try - { - result = Dali::Scene3D::BlendShapeIndex::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::BlendShapeIndex((const Dali::Scene3D::BlendShapeIndex&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_BlendShapeIndex_New_SWIG_1(void* csBlendShapePropertyKey) -{ - Dali::Property::Key* blendShapePropertyKey = (Dali::Property::Key*)csBlendShapePropertyKey; - Dali::Scene3D::BlendShapeIndex result; - - if(!blendShapePropertyKey) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0); - return 0; - } - { - try - { - result = Dali::Scene3D::BlendShapeIndex::New(*blendShapePropertyKey); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::BlendShapeIndex((const Dali::Scene3D::BlendShapeIndex&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_BlendShapeIndex_New_SWIG_2(void* csModelNodePropertKey, void* csBlendShapePropertyKey) -{ - Dali::Property::Key* modelNodePropertyKey = (Dali::Property::Key*)csModelNodePropertKey; - Dali::Property::Key* blendShapePropertyKey = (Dali::Property::Key*)csBlendShapePropertyKey; - Dali::Scene3D::BlendShapeIndex result; - - if(!modelNodePropertyKey) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "modelNodePropertyKey Dali::Property::Key const & type is null", 0); - return 0; - } - if(!blendShapePropertyKey) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "blendShapePropertyKey Dali::Property::Key const & type is null", 0); - return 0; - } - { - try - { - result = Dali::Scene3D::BlendShapeIndex::New(*modelNodePropertyKey, *blendShapePropertyKey); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::BlendShapeIndex((const Dali::Scene3D::BlendShapeIndex&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_BlendShapeIndex_SWIG_0() -{ - Dali::Scene3D::BlendShapeIndex* result = 0; - - { - try - { - result = (Dali::Scene3D::BlendShapeIndex*)new Dali::Scene3D::BlendShapeIndex(); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_BlendShapeIndex_SWIG_1(void* csBlendShapeIndex) -{ - Dali::Scene3D::BlendShapeIndex* blendShapeIndex = (Dali::Scene3D::BlendShapeIndex*)csBlendShapeIndex; - Dali::Scene3D::BlendShapeIndex* result = 0; - - if(!blendShapeIndex) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::BlendShapeIndex const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::BlendShapeIndex*)new Dali::Scene3D::BlendShapeIndex((Dali::Scene3D::BlendShapeIndex const&)*blendShapeIndex); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BlendShapeIndex(void* csBlendShapeIndex) -{ - Dali::Scene3D::BlendShapeIndex* blendShapeIndex = (Dali::Scene3D::BlendShapeIndex*)csBlendShapeIndex; - { - try - { - delete blendShapeIndex; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_BlendShapeIndex_Assign(void* csDestination, void* csSource) -{ - Dali::Scene3D::BlendShapeIndex* destination = (Dali::Scene3D::BlendShapeIndex*)csDestination; - Dali::Scene3D::BlendShapeIndex* source = (Dali::Scene3D::BlendShapeIndex*)csSource; - Dali::Scene3D::BlendShapeIndex* result = 0; - - if(!source) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::BlendShapeIndex const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::BlendShapeIndex*)&(destination)->operator=((Dali::Scene3D::BlendShapeIndex const&)*source); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_BlendShapeIndex_DownCast(void* csHandle) -{ - Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; - Dali::Scene3D::BlendShapeIndex result; - - if(!handle) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return 0; - } - { - try - { - result = Dali::Scene3D::BlendShapeIndex::DownCast(*handle); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::BlendShapeIndex((const Dali::Scene3D::BlendShapeIndex&)result); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BlendShapeIndex_SetBlendShapeId(void* csBlendShapeIndex, void* csBlendShapePropertyKey) -{ - Dali::Scene3D::BlendShapeIndex* blendShapeIndex = (Dali::Scene3D::BlendShapeIndex*)csBlendShapeIndex; - Dali::Property::Key* blendShapePropertyKey = (Dali::Property::Key*)csBlendShapePropertyKey; - - if(!blendShapeIndex) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::BlendShapeIndex const & type is null", 0); - return; - } - if(!blendShapePropertyKey) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0); - return; - } - { - try - { - blendShapeIndex->SetBlendShapeId(*blendShapePropertyKey); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_BlendShapeIndex_GetBlendShapeId(void* csBlendShapeIndex) -{ - Dali::Scene3D::BlendShapeIndex* blendShapeIndex = (Dali::Scene3D::BlendShapeIndex*)csBlendShapeIndex; - Dali::Property::Key result = Dali::Property::INVALID_KEY; - - if(!blendShapeIndex) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::BlendShapeIndex const & type is null", 0); - return 0; - } - { - try - { - result = blendShapeIndex->GetBlendShapeId(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Property::Key((Dali::Property::Key const &)result); -} - -// MotionPropertyIndex - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionPropertyIndex_New_SWIG_0() -{ - Dali::Scene3D::MotionPropertyIndex result; - - { - try - { - result = Dali::Scene3D::MotionPropertyIndex::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::MotionPropertyIndex((const Dali::Scene3D::MotionPropertyIndex&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionPropertyIndex_New_SWIG_1(void* csModelNodePropertKey, void* csPropertyKey) -{ - Dali::Property::Key* modelNodePropertyKey = (Dali::Property::Key*)csModelNodePropertKey; - Dali::Property::Key* propertyKey = (Dali::Property::Key*)csPropertyKey; - Dali::Scene3D::MotionPropertyIndex result; - - if(!modelNodePropertyKey) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "modelNodePropertyKey Dali::Property::Key const & type is null", 0); - return 0; - } - if(!propertyKey) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "propertyKey Dali::Property::Key const & type is null", 0); - return 0; - } - { - try - { - result = Dali::Scene3D::MotionPropertyIndex::New(*modelNodePropertyKey, *propertyKey); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::MotionPropertyIndex((const Dali::Scene3D::MotionPropertyIndex&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionPropertyIndex_SWIG_0() -{ - Dali::Scene3D::MotionPropertyIndex* result = 0; - - { - try - { - result = (Dali::Scene3D::MotionPropertyIndex*)new Dali::Scene3D::MotionPropertyIndex(); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionPropertyIndex_SWIG_1(void* csMotionPropertyIndex) -{ - Dali::Scene3D::MotionPropertyIndex* motionPropertyIndex = (Dali::Scene3D::MotionPropertyIndex*)csMotionPropertyIndex; - Dali::Scene3D::MotionPropertyIndex* result = 0; - - if(!motionPropertyIndex) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionPropertyIndex const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::MotionPropertyIndex*)new Dali::Scene3D::MotionPropertyIndex((Dali::Scene3D::MotionPropertyIndex const&)*motionPropertyIndex); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MotionPropertyIndex(void* csMotionPropertyIndex) -{ - Dali::Scene3D::MotionPropertyIndex* motionPropertyIndex = (Dali::Scene3D::MotionPropertyIndex*)csMotionPropertyIndex; - { - try - { - delete motionPropertyIndex; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionPropertyIndex_Assign(void* csDestination, void* csSource) -{ - Dali::Scene3D::MotionPropertyIndex* destination = (Dali::Scene3D::MotionPropertyIndex*)csDestination; - Dali::Scene3D::MotionPropertyIndex* source = (Dali::Scene3D::MotionPropertyIndex*)csSource; - Dali::Scene3D::MotionPropertyIndex* result = 0; - - if(!source) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionPropertyIndex const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::MotionPropertyIndex*)&(destination)->operator=((Dali::Scene3D::MotionPropertyIndex const&)*source); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionPropertyIndex_DownCast(void* csHandle) -{ - Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; - Dali::Scene3D::MotionPropertyIndex result; - - if(!handle) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return 0; - } - { - try - { - result = Dali::Scene3D::MotionPropertyIndex::DownCast(*handle); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::MotionPropertyIndex((const Dali::Scene3D::MotionPropertyIndex&)result); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionPropertyIndex_SetPropertyId(void* csMotionPropertyIndex, void* csPropertyKey) -{ - Dali::Scene3D::MotionPropertyIndex* motionPropertyIndex = (Dali::Scene3D::MotionPropertyIndex*)csMotionPropertyIndex; - Dali::Property::Key* propertyKey = (Dali::Property::Key*)csPropertyKey; - - if(!motionPropertyIndex) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionPropertyIndex const & type is null", 0); - return; - } - if(!propertyKey) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0); - return; - } - { - try - { - motionPropertyIndex->SetPropertyId(*propertyKey); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionPropertyIndex_GetPropertyId(void* csMotionPropertyIndex) -{ - Dali::Scene3D::MotionPropertyIndex* motionPropertyIndex = (Dali::Scene3D::MotionPropertyIndex*)csMotionPropertyIndex; - Dali::Property::Key result = Dali::Property::INVALID_KEY; - - if(!motionPropertyIndex) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionPropertyIndex const & type is null", 0); - return 0; - } - { - try - { - result = motionPropertyIndex->GetPropertyId(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Property::Key((Dali::Property::Key const &)result); -} - -// MotionTransformIndex - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionTransformIndex_New_SWIG_0() -{ - Dali::Scene3D::MotionTransformIndex result; - - { - try - { - result = Dali::Scene3D::MotionTransformIndex::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::MotionTransformIndex((const Dali::Scene3D::MotionTransformIndex&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionTransformIndex_New_SWIG_1(void* csModelNodePropertKey, int csTransformType) -{ - Dali::Property::Key* modelNodePropertyKey = (Dali::Property::Key*)csModelNodePropertKey; - Dali::Scene3D::MotionTransformIndex result; - - if(!modelNodePropertyKey) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "modelNodePropertyKey Dali::Property::Key const & type is null", 0); - return 0; - } - { - try - { - result = Dali::Scene3D::MotionTransformIndex::New(*modelNodePropertyKey, static_cast(csTransformType)); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::MotionTransformIndex((const Dali::Scene3D::MotionTransformIndex&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionTransformIndex_SWIG_0() -{ - Dali::Scene3D::MotionTransformIndex* result = 0; - - { - try - { - result = (Dali::Scene3D::MotionTransformIndex*)new Dali::Scene3D::MotionTransformIndex(); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionTransformIndex_SWIG_1(void* csMotionTransformIndex) -{ - Dali::Scene3D::MotionTransformIndex* motionTransformIndex = (Dali::Scene3D::MotionTransformIndex*)csMotionTransformIndex; - Dali::Scene3D::MotionTransformIndex* result = 0; - - if(!motionTransformIndex) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionTransformIndex const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::MotionTransformIndex*)new Dali::Scene3D::MotionTransformIndex((Dali::Scene3D::MotionTransformIndex const&)*motionTransformIndex); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MotionTransformIndex(void* csMotionTransformIndex) -{ - Dali::Scene3D::MotionTransformIndex* motionTransformIndex = (Dali::Scene3D::MotionTransformIndex*)csMotionTransformIndex; - { - try - { - delete motionTransformIndex; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionTransformIndex_Assign(void* csDestination, void* csSource) -{ - Dali::Scene3D::MotionTransformIndex* destination = (Dali::Scene3D::MotionTransformIndex*)csDestination; - Dali::Scene3D::MotionTransformIndex* source = (Dali::Scene3D::MotionTransformIndex*)csSource; - Dali::Scene3D::MotionTransformIndex* result = 0; - - if(!source) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionTransformIndex const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::MotionTransformIndex*)&(destination)->operator=((Dali::Scene3D::MotionTransformIndex const&)*source); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionTransformIndex_DownCast(void* csHandle) -{ - Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; - Dali::Scene3D::MotionTransformIndex result; - - if(!handle) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return 0; - } - { - try - { - result = Dali::Scene3D::MotionTransformIndex::DownCast(*handle); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::MotionTransformIndex((const Dali::Scene3D::MotionTransformIndex&)result); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionTransformIndex_SetTransformType(void* csMotionTransformIndex, int csTransformType) -{ - Dali::Scene3D::MotionTransformIndex* motionTransformIndex = (Dali::Scene3D::MotionTransformIndex*)csMotionTransformIndex; - - if(!motionTransformIndex) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionTransformIndex const & type is null", 0); - return; - } - { - try - { - motionTransformIndex->SetTransformType(static_cast(csTransformType)); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MotionTransformIndex_GetTransformType(void* csMotionTransformIndex) -{ - Dali::Scene3D::MotionTransformIndex* motionTransformIndex = (Dali::Scene3D::MotionTransformIndex*)csMotionTransformIndex; - int result; - - if(!motionTransformIndex) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionTransformIndex const & type is null", 0); - return 0; - } - { - try - { - result = static_cast(motionTransformIndex->GetTransformType()); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/motion-value-wrap.cpp b/dali-csharp-binder/src/motion-value-wrap.cpp deleted file mode 100644 index a52c91f1..00000000 --- a/dali-csharp-binder/src/motion-value-wrap.cpp +++ /dev/null @@ -1,309 +0,0 @@ -/* - * Copyright (c) 2023 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_New_SWIG_0() -{ - Dali::Scene3D::MotionValue result; - - { - try - { - result = Dali::Scene3D::MotionValue::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::MotionValue((const Dali::Scene3D::MotionValue&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_New_SWIG_1(void* csPropertyValue) -{ - Dali::Property::Value* propertyValue = (Dali::Property::Value*)csPropertyValue; - Dali::Scene3D::MotionValue result; - - if(!propertyValue) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); - return 0; - } - { - try - { - result = Dali::Scene3D::MotionValue::New(*propertyValue); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::MotionValue((const Dali::Scene3D::MotionValue&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_New_SWIG_2(void* csKeyFrames) -{ - Dali::KeyFrames* keyFrames = (Dali::KeyFrames*)csKeyFrames; - Dali::Scene3D::MotionValue result; - - if(!keyFrames) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0); - return 0; - } - { - try - { - result = Dali::Scene3D::MotionValue::New(*keyFrames); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::MotionValue((const Dali::Scene3D::MotionValue&)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionValue_SWIG_0() -{ - Dali::Scene3D::MotionValue* result = 0; - - { - try - { - result = (Dali::Scene3D::MotionValue*)new Dali::Scene3D::MotionValue(); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_MotionValue_SWIG_1(void* csMotionValue) -{ - Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue; - Dali::Scene3D::MotionValue* result = 0; - - if(!motionValue) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionValue const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::MotionValue*)new Dali::Scene3D::MotionValue((Dali::Scene3D::MotionValue const&)*motionValue); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MotionValue(void* csMotionValue) -{ - Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue; - { - try - { - delete motionValue; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_Assign(void* csDestination, void* csSource) -{ - Dali::Scene3D::MotionValue* destination = (Dali::Scene3D::MotionValue*)csDestination; - Dali::Scene3D::MotionValue* source = (Dali::Scene3D::MotionValue*)csSource; - Dali::Scene3D::MotionValue* result = 0; - - if(!source) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::MotionValue const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::MotionValue*)&(destination)->operator=((Dali::Scene3D::MotionValue const&)*source); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void*)result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_DownCast(void* csHandle) -{ - Dali::BaseHandle* handle = (Dali::BaseHandle*)csHandle; - Dali::Scene3D::MotionValue result; - - if(!handle) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::Model", 0); - return 0; - } - { - try - { - result = Dali::Scene3D::MotionValue::DownCast(*handle); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::MotionValue((const Dali::Scene3D::MotionValue&)result); -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MotionValue_GetValueType(void* csMotionValue) -{ - Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue; - int result; - - if(!motionValue) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0); - return 0; - } - { - try - { - result = static_cast(motionValue->GetValueType()); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionValue_SetValue_PropertyValue(void* csMotionValue, void* csPropertyValue) -{ - Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue; - Dali::Property::Value* propertyValue = (Dali::Property::Value*)csPropertyValue; - - if(!motionValue) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0); - return; - } - if(!propertyValue) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0); - return; - } - { - try - { - motionValue->SetValue(*propertyValue); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionValue_SetValue_KeyFrames(void* csMotionValue, void* csKeyFrames) -{ - Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue; - Dali::KeyFrames* keyFrames = (Dali::KeyFrames*)csKeyFrames; - - if(!motionValue) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0); - return; - } - if(!keyFrames) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0); - return; - } - { - try - { - motionValue->SetValue(*keyFrames); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MotionValue_Clear(void* csMotionValue) -{ - Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue; - - if(!motionValue) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0); - return; - } - { - try - { - motionValue->Clear(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_GetPropertyValue(void* csMotionValue) -{ - Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue; - Dali::Property::Value result; - - if(!motionValue) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0); - return 0; - } - { - try - { - result = motionValue->GetPropertyValue(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Property::Value((Dali::Property::Value const &)result); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_MotionValue_GetKeyFrames(void* csMotionValue) -{ - Dali::Scene3D::MotionValue* motionValue = (Dali::Scene3D::MotionValue*)csMotionValue; - Dali::KeyFrames result; - - if(!motionValue) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::MotionValue", 0); - return 0; - } - { - try - { - result = motionValue->GetKeyFrames(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::KeyFrames((Dali::KeyFrames const &)result); -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/native-image-queue-wrap.cpp b/dali-csharp-binder/src/native-image-queue-wrap.cpp deleted file mode 100644 index 4eba0db4..00000000 --- a/dali-csharp-binder/src/native-image-queue-wrap.cpp +++ /dev/null @@ -1,112 +0,0 @@ -/* - * Copyright (c) 2021 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -struct NativeImageSourceQueuePtrHandle -{ - Dali::NativeImageSourceQueuePtr Ptr; -}; - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_NativeImageQueuePtr(unsigned int width, unsigned int height, int colorFormat) -{ - void* jresult; - NativeImageSourceQueuePtrHandle* queue = new NativeImageSourceQueuePtrHandle(); - { - try { - queue->Ptr = Dali::NativeImageSourceQueue::New(width, height, (Dali::NativeImageSourceQueue::ColorFormat)colorFormat); - } - CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)queue; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageQueue_GetPtr(void* nuiqueue) -{ - void* jresult; - NativeImageSourceQueuePtrHandle* queue = (NativeImageSourceQueuePtrHandle*)nuiqueue; - jresult = (void*)(queue->Ptr.Get()); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImageQueuePtr(void* nuiqueue) -{ - NativeImageSourceQueuePtrHandle* queue = (NativeImageSourceQueuePtrHandle*)nuiqueue; - { - try { - delete queue; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageQueue_CanDequeueBuffer(void* nuiqueue) -{ - bool jresult; - Dali::NativeImageSourceQueue* queue = (Dali::NativeImageSourceQueue*)nuiqueue; - { - try { - jresult = queue->CanDequeueBuffer(); - } - CALL_CATCH_EXCEPTION(0); - } - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageQueue_DequeueBuffer(void* nuiqueue, int* jwidth, int* jheight, int* jstride) -{ - void* jresult; - Dali::NativeImageSourceQueue* queue = (Dali::NativeImageSourceQueue*)nuiqueue; - uint32_t* width = (uint32_t*)(jwidth); - uint32_t* height = (uint32_t*)(jheight); - uint32_t* stride = (uint32_t*)(jstride); - { - try { - jresult = (void *)queue->DequeueBuffer( *width, *height, *stride ); - } - CALL_CATCH_EXCEPTION(0); - } - return jresult; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageQueue_EnqueueBuffer(void* nuiqueue, void* jbuffer) -{ - bool jresult; - Dali::NativeImageSourceQueue* queue = (Dali::NativeImageSourceQueue*)nuiqueue; - uint8_t* buffer = (uint8_t*)jbuffer; - { - try { - jresult = queue->EnqueueBuffer(buffer); - } - CALL_CATCH_EXCEPTION(0); - } - return jresult; -} - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/nui-view-accessible.cpp b/dali-csharp-binder/src/nui-view-accessible.cpp deleted file mode 100644 index eeaf0c2e..00000000 --- a/dali-csharp-binder/src/nui-view-accessible.cpp +++ /dev/null @@ -1,723 +0,0 @@ -/* - * Copyright (c) 2023 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. - * - */ - -// CLASS HEADER -#include "nui-view-accessible.h" - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "control-devel-wrap.h" - -using namespace Dali; -using namespace Dali::Toolkit; - -using Interface = Accessibility::AtspiInterface; -using IntPairType = NUIViewAccessible::IntPairType; -using IntVectorType = NUIViewAccessible::IntVectorType; - -namespace -{ -void GetAttributesCallback(const char* key, const char* value, Accessibility::Attributes* attributes) -{ - attributes->insert_or_assign(key, value); -} - -void GetSelectedRowsColumnsCallback(int index, IntVectorType* vector) -{ - vector->push_back(index); -} - -using GetAttributesCallbackType = decltype(&GetAttributesCallback); -using GetSelectedRowsColumnsCallbackType = decltype(&GetSelectedRowsColumnsCallback); - -} // unnamed namespace - -// Keep this structure layout binary compatible with the respective C# structure! -struct NUIViewAccessible::AccessibilityDelegate -{ - AccessibilityDelegate() = delete; - - // clang-format off - char* (*getName) (RefObject*); // 1 - char* (*getDescription) (RefObject*); // 2 - bool (*doAction) (RefObject*, const char*); // 3 - std::uint64_t (*calculateStates) (RefObject*, std::uint64_t); // 4 - int (*getActionCount) (RefObject*); // 5 - char* (*getActionName) (RefObject*, int); // 6 - std::uint32_t (*getInterfaces) (RefObject*); // 7 - double (*getMinimum) (RefObject*); // 8 - double (*getCurrent) (RefObject*); // 9 - double (*getMaximum) (RefObject*); // 10 - bool (*setCurrent) (RefObject*, double); // 11 - double (*getMinimumIncrement) (RefObject*); // 12 - bool (*isScrollable) (RefObject*); // 13 - char* (*getText) (RefObject*, int, int); // 14 - int (*getCharacterCount) (RefObject*); // 15 - int (*getCursorOffset) (RefObject*); // 16 - bool (*setCursorOffset) (RefObject*, int); // 17 - Accessibility::Range* (*getTextAtOffset) (RefObject*, int, int); // 18 - Accessibility::Range* (*getRangeOfSelection) (RefObject*, int); // 19 - bool (*removeSelection) (RefObject*, int); // 20 - bool (*setRangeOfSelection) (RefObject*, int, int, int); // 21 - bool (*copyText) (RefObject*, int, int); // 22 - bool (*cutText) (RefObject*, int, int); // 23 - bool (*insertText) (RefObject*, int, const char*); // 24 - bool (*setTextContents) (RefObject*, const char*); // 25 - bool (*deleteText) (RefObject*, int, int); // 26 - bool (*scrollToChild) (RefObject*, Actor*); // 27 - int (*getSelectedChildrenCount)(RefObject*); // 28 - Actor* (*getSelectedChild) (RefObject*, int); // 29 - bool (*selectChild) (RefObject*, int); // 30 - bool (*deselectSelectedChild) (RefObject*, int); // 31 - bool (*isChildSelected) (RefObject*, int); // 32 - bool (*selectAll) (RefObject*); // 33 - bool (*clearSelection) (RefObject*); // 34 - bool (*deselectChild) (RefObject*, int); // 35 - Rect* (*getRangeExtents) (RefObject*, int, int, int); // 36 - void (*getAttributes) (RefObject*, GetAttributesCallbackType, Accessibility::Attributes*); // 37 - char* (*getValueText) (RefObject*); // 38 - int (*getRowCount) (RefObject*); // 39 - int (*getColumnCount) (RefObject*); // 40 - int (*getSelectedRowCount) (RefObject*); // 41 - int (*getSelectedColumnCount) (RefObject*); // 42 - Actor* (*getCaption) (RefObject*); // 43 - Actor* (*getSummary) (RefObject*); // 44 - Actor* (*getCell) (RefObject*, int, int); // 45 - std::uint64_t (*getChildIndex) (RefObject*, int, int); // 46 - IntPairType* (*getPositionByChildIndex) (RefObject*, std::uint64_t); // 47 - char* (*getRowDescription) (RefObject*, int); // 48 - char* (*getColumnDescription) (RefObject*, int); // 49 - Actor* (*getRowHeader) (RefObject*, int); // 50 - Actor* (*getColumnHeader) (RefObject*, int); // 51 - void (*getSelectedRows) (RefObject*, GetSelectedRowsColumnsCallbackType, IntVectorType*); // 52 - void (*getSelectedColumns) (RefObject*, GetSelectedRowsColumnsCallbackType, IntVectorType*); // 53 - bool (*isRowSelected) (RefObject*, int); // 54 - bool (*isColumnSelected) (RefObject*, int); // 55 - bool (*isCellSelected) (RefObject*, int, int); // 56 - bool (*addRowSelection) (RefObject*, int); // 57 - bool (*addColumnSelection) (RefObject*, int); // 58 - bool (*removeRowSelection) (RefObject*, int); // 59 - bool (*removeColumnSelection) (RefObject*, int); // 60 - Actor* (*getTable) (RefObject*); // 61 - IntPairType* (*getCellPosition) (RefObject*); // 62 - int (*getCellRowSpan) (RefObject*); // 63 - int (*getCellColumnSpan) (RefObject*); // 64 - // clang-format on -}; - -NUIViewAccessible::NUIViewAccessible(Actor actor) -: ControlAccessible(actor) -{ - DALI_ASSERT_DEBUG(mTable); -} - -void NUIViewAccessible::SetAccessibilityDelegate(const AccessibilityDelegate* accessibilityDelegate) -{ - if(mTable) - { - DALI_LOG_ERROR("Overwriting global AccessibilityDelegate"); - } - - mTable = accessibilityDelegate; -} - -std::string NUIViewAccessible::StealString(char* str) -{ - std::string ret{}; - - if(str) - { - ret = {str}; - free(str); - } - - return ret; -} - -template -T NUIViewAccessible::StealObject(T* obj) -{ - T ret{}; - - if(obj) - { - ret = std::move(*obj); - delete obj; - } - - return ret; -} - -template -R NUIViewAccessible::CallMethod(R (*method)(RefObject*, Args...), Args... args) const -{ - DALI_ASSERT_DEBUG(method); - DALI_ASSERT_ALWAYS(GetInterfaces()[I]); - - return method(Self().GetObjectPtr(), args...); -} - -// -// Standard interfaces (Accessible, Action, Component) -// - -std::string NUIViewAccessible::GetNameRaw() const -{ - char* name = CallMethod(mTable->getName); - - return StealString(name); -} - -std::string NUIViewAccessible::GetDescriptionRaw() const -{ - char* description = CallMethod(mTable->getDescription); - - return StealString(description); -} - -bool NUIViewAccessible::GrabHighlight() -{ - bool ret = ControlAccessible::GrabHighlight(); - - if(ret) - { - // Note: Currently (2021-03-26), size negotiation between the default highlight frame - // and NUI Components is known to be broken (and possibly in other cases, too). Please - // remove this for GrabHighlight() when it is fixed. - auto size = Self().GetProperty(Actor::Property::SIZE); - mCurrentHighlightActor.GetHandle().SetProperty(Actor::Property::SIZE, size); - } - - return ret; -} - -std::string NUIViewAccessible::GetActionName(std::size_t index) const -{ - char* name = CallMethod(mTable->getActionName, static_cast(index)); - - return StealString(name); -} - -std::size_t NUIViewAccessible::GetActionCount() const -{ - int count = CallMethod(mTable->getActionCount); - - return static_cast(count); -} - -bool NUIViewAccessible::DoAction(std::size_t index) -{ - return DoAction(GetActionName(index)); -} - -bool NUIViewAccessible::DoAction(const std::string& name) -{ - return CallMethod(mTable->doAction, name.c_str()); -} - -Accessibility::States NUIViewAccessible::CalculateStates() -{ - std::uint64_t states = ControlAccessible::CalculateStates().GetRawData64(); - - states = CallMethod(mTable->calculateStates, states); - - return Accessibility::States{states}; -} - -Accessibility::Attributes NUIViewAccessible::GetAttributes() const -{ - auto attributes = ControlAccessible::GetAttributes(); - - CallMethod(mTable->getAttributes, &GetAttributesCallback, &attributes); - - return attributes; -} - -Property::Index NUIViewAccessible::GetNamePropertyIndex() -{ - return Property::INVALID_INDEX; -} - -Property::Index NUIViewAccessible::GetDescriptionPropertyIndex() -{ - return Property::INVALID_INDEX; -} - -bool NUIViewAccessible::IsScrollable() const -{ - return CallMethod(mTable->isScrollable); -} - -bool NUIViewAccessible::ScrollToChild(Actor child) -{ - return CallMethod(mTable->scrollToChild, new Actor(child)); -} - -Accessibility::AtspiInterfaces NUIViewAccessible::DoGetInterfaces() const -{ - using Interfaces = Accessibility::AtspiInterfaces; - - Interfaces baseInterfaces; - Interfaces extraInterfaces; - - // These are always implemented - baseInterfaces[Interface::ACCESSIBLE] = true; - baseInterfaces[Interface::ACTION] = true; - baseInterfaces[Interface::COLLECTION] = true; - baseInterfaces[Interface::COMPONENT] = true; - - // We cannot use CallMethod() here as that would cause recursion. - // Note that the result will be cached and subsequent calls to GetInterfaces() - // will not involve calling this virtual method or jumping into C# code. - extraInterfaces = Interfaces{mTable->getInterfaces(Self().GetObjectPtr())}; - - return baseInterfaces | extraInterfaces; -} - -// -// Value interface -// - -double NUIViewAccessible::GetMinimum() const -{ - return CallMethod(mTable->getMinimum); -} - -double NUIViewAccessible::GetCurrent() const -{ - return CallMethod(mTable->getCurrent); -} - -std::string NUIViewAccessible::GetValueText() const -{ - char *text = CallMethod(mTable->getValueText); - - return StealString(text); -} - -double NUIViewAccessible::GetMaximum() const -{ - return CallMethod(mTable->getMaximum); -} - -bool NUIViewAccessible::SetCurrent(double value) -{ - return CallMethod(mTable->setCurrent, value); -} - -double NUIViewAccessible::GetMinimumIncrement() const -{ - return CallMethod(mTable->getMinimumIncrement); -} - -// -// Text interface -// - -std::string NUIViewAccessible::GetText(std::size_t startOffset, std::size_t endOffset) const -{ - char* text = CallMethod(mTable->getText, static_cast(startOffset), static_cast(endOffset)); - - return StealString(text); -} - -std::size_t NUIViewAccessible::GetCharacterCount() const -{ - int count = CallMethod(mTable->getCharacterCount); - - return static_cast(count); -} - -std::size_t NUIViewAccessible::GetCursorOffset() const -{ - int offset = CallMethod(mTable->getCursorOffset); - - return static_cast(offset); -} - -bool NUIViewAccessible::SetCursorOffset(std::size_t offset) -{ - return CallMethod(mTable->setCursorOffset, static_cast(offset)); -} - -Accessibility::Range NUIViewAccessible::GetTextAtOffset(std::size_t offset, Accessibility::TextBoundary boundary) const -{ - Accessibility::Range* range = CallMethod(mTable->getTextAtOffset, static_cast(offset), static_cast(boundary)); - - return StealObject(range); -} - -Accessibility::Range NUIViewAccessible::GetRangeOfSelection(std::size_t selectionIndex) const -{ - Accessibility::Range* range = CallMethod(mTable->getRangeOfSelection, static_cast(selectionIndex)); - - return StealObject(range); -} - -bool NUIViewAccessible::RemoveSelection(std::size_t selectionIndex) -{ - return CallMethod(mTable->removeSelection, static_cast(selectionIndex)); -} - -bool NUIViewAccessible::SetRangeOfSelection(std::size_t selectionIndex, std::size_t startOffset, std::size_t endOffset) -{ - return CallMethod(mTable->setRangeOfSelection, static_cast(selectionIndex), static_cast(startOffset), static_cast(endOffset)); -} - -Rect<> NUIViewAccessible::GetRangeExtents(std::size_t startOffset, std::size_t endOffset, Accessibility::CoordinateType type) -{ - auto rectPtr = CallMethod(mTable->getRangeExtents, static_cast(startOffset), static_cast(endOffset), static_cast(type)); - Rect rect = StealObject(rectPtr); - - return {(float)rect.x, (float)rect.y, (float)rect.width, (float)rect.height}; -} - -// -// EditableText interface -// - -bool NUIViewAccessible::CopyText(std::size_t startPosition, std::size_t endPosition) -{ - return CallMethod(mTable->copyText, static_cast(startPosition), static_cast(endPosition)); -} - -bool NUIViewAccessible::CutText(std::size_t startPosition, std::size_t endPosition) -{ - return CallMethod(mTable->cutText, static_cast(startPosition), static_cast(endPosition)); -} - -bool NUIViewAccessible::InsertText(std::size_t startPosition, std::string text) -{ - return CallMethod(mTable->insertText, static_cast(startPosition), text.c_str()); -} - -bool NUIViewAccessible::SetTextContents(std::string newContents) -{ - return CallMethod(mTable->setTextContents, newContents.c_str()); -} - -bool NUIViewAccessible::DeleteText(std::size_t startPosition, std::size_t endPosition) -{ - return CallMethod(mTable->deleteText, static_cast(startPosition), static_cast(endPosition)); -} - -// -// Selection interface -// - -int NUIViewAccessible::GetSelectedChildrenCount() const -{ - return CallMethod(mTable->getSelectedChildrenCount); -} - -Accessibility::Accessible* NUIViewAccessible::GetSelectedChild(int selectedChildIndex) -{ - Actor* actor = CallMethod(mTable->getSelectedChild, selectedChildIndex); - - return actor ? Accessibility::Accessible::Get(*actor) : nullptr; -} - -bool NUIViewAccessible::SelectChild(int childIndex) -{ - return CallMethod(mTable->selectChild, childIndex); -} - -bool NUIViewAccessible::DeselectSelectedChild(int selectedChildIndex) -{ - return CallMethod(mTable->deselectSelectedChild, selectedChildIndex); -} - -bool NUIViewAccessible::IsChildSelected(int childIndex) const -{ - return CallMethod(mTable->isChildSelected, childIndex); -} - -bool NUIViewAccessible::SelectAll() -{ - return CallMethod(mTable->selectAll); -} - -bool NUIViewAccessible::ClearSelection() -{ - return CallMethod(mTable->clearSelection); -} - -bool NUIViewAccessible::DeselectChild(int childIndex) -{ - return CallMethod(mTable->deselectChild, childIndex); -} - -// -// Table interface -// - -int NUIViewAccessible::GetRowCount() const -{ - return CallMethod(mTable->getRowCount); -} - -int NUIViewAccessible::GetColumnCount() const -{ - return CallMethod(mTable->getColumnCount); -} - -int NUIViewAccessible::GetSelectedRowCount() const -{ - return CallMethod(mTable->getSelectedRowCount); -} - -int NUIViewAccessible::GetSelectedColumnCount() const -{ - return CallMethod(mTable->getSelectedColumnCount); -} - -Accessibility::Accessible* NUIViewAccessible::GetCaption() const -{ - Actor* caption = CallMethod(mTable->getCaption); - - return caption ? Accessibility::Accessible::Get(*caption) : nullptr; -} - -Accessibility::Accessible* NUIViewAccessible::GetSummary() const -{ - Actor* summary = CallMethod(mTable->getSummary); - - return summary ? Accessibility::Accessible::Get(*summary) : nullptr; -} - -Accessibility::TableCell* NUIViewAccessible::GetCell(int row, int column) const -{ - Actor* cell = CallMethod(mTable->getCell, row, column); - - return cell ? Accessibility::TableCell::DownCast(Accessibility::Accessible::Get(*cell)) : nullptr; -} - -std::size_t NUIViewAccessible::GetChildIndex(int row, int column) const -{ - std::uint64_t index = CallMethod(mTable->getChildIndex, row, column); - - return static_cast(index); -} - -IntPairType NUIViewAccessible::GetPositionByChildIndex(std::size_t childIndex) const -{ - IntPairType* position = CallMethod(mTable->getPositionByChildIndex, static_cast(childIndex)); - - return StealObject(position); -} - -int NUIViewAccessible::GetRowByChildIndex(std::size_t childIndex) const -{ - return GetPositionByChildIndex(childIndex).first; -} - -int NUIViewAccessible::GetColumnByChildIndex(std::size_t childIndex) const -{ - return GetPositionByChildIndex(childIndex).second; -} - -std::string NUIViewAccessible::GetRowDescription(int row) const -{ - char* description = CallMethod(mTable->getRowDescription, row); - - return StealString(description); -} - -std::string NUIViewAccessible::GetColumnDescription(int column) const -{ - char* description = CallMethod(mTable->getColumnDescription, column); - - return StealString(description); -} - -int NUIViewAccessible::GetRowSpan(int row, int column) const -{ - Accessibility::TableCell* cell = GetCell(row, column); - - return cell ? cell->GetCellRowSpan() : -1; -} - -int NUIViewAccessible::GetColumnSpan(int row, int column) const -{ - Accessibility::TableCell* cell = GetCell(row, column); - - return cell ? cell->GetCellColumnSpan() : -1; -} - -Accessibility::Accessible* NUIViewAccessible::GetRowHeader(int row) const -{ - Actor* header = CallMethod(mTable->getRowHeader, row); - - return header ? Accessibility::Accessible::Get(*header) : nullptr; -} - -Accessibility::Accessible* NUIViewAccessible::GetColumnHeader(int column) const -{ - Actor* header = CallMethod(mTable->getColumnHeader, column); - - return header ? Accessibility::Accessible::Get(*header) : nullptr; -} - -IntVectorType NUIViewAccessible::GetSelectedRows() const -{ - IntVectorType result; - - CallMethod(mTable->getSelectedRows, &GetSelectedRowsColumnsCallback, &result); - - return result; -} - -IntVectorType NUIViewAccessible::GetSelectedColumns() const -{ - IntVectorType result; - - CallMethod(mTable->getSelectedColumns, &GetSelectedRowsColumnsCallback, &result); - - return result; -} - -bool NUIViewAccessible::IsRowSelected(int row) const -{ - return CallMethod(mTable->isRowSelected, row); -} - -bool NUIViewAccessible::IsColumnSelected(int column) const -{ - return CallMethod(mTable->isColumnSelected, column); -} - -bool NUIViewAccessible::IsCellSelected(int row, int column) const -{ - return CallMethod(mTable->isCellSelected, row, column); -} - -bool NUIViewAccessible::AddRowSelection(int row) -{ - return CallMethod(mTable->addRowSelection, row); -} - -bool NUIViewAccessible::AddColumnSelection(int column) -{ - return CallMethod(mTable->addColumnSelection, column); -} - -bool NUIViewAccessible::RemoveRowSelection(int row) -{ - return CallMethod(mTable->removeRowSelection, row); -} - -bool NUIViewAccessible::RemoveColumnSelection(int column) -{ - return CallMethod(mTable->removeColumnSelection, column); -} - -Accessibility::Table::RowColumnSpanType NUIViewAccessible::GetRowColumnSpan(std::size_t childIndex) const -{ - Accessibility::Table::RowColumnSpanType span{.success = false}; - - std::tie(span.row, span.column) = GetPositionByChildIndex(childIndex); - Accessibility::TableCell* cell = GetCell(span.row, span.column); - if (!cell) - { - return span; - } - - span.success = true; - span.isSelected = IsCellSelected(span.row, span.column); - span.rowSpan = cell->GetCellRowSpan(); - span.columnSpan = cell->GetCellColumnSpan(); - - return span; -} - -// -// TableCell interface -// - -Accessibility::Table* NUIViewAccessible::GetTable() const -{ - Actor* table = CallMethod(mTable->getTable); - - return table ? Accessibility::Table::DownCast(Accessibility::Accessible::Get(*table)) : nullptr; -} - -IntPairType NUIViewAccessible::GetCellPosition() const -{ - IntPairType* position = CallMethod(mTable->getCellPosition); - - return StealObject(position); -} - -int NUIViewAccessible::GetCellRowSpan() const -{ - return CallMethod(mTable->getCellRowSpan); -} - -int NUIViewAccessible::GetCellColumnSpan() const -{ - return CallMethod(mTable->getCellColumnSpan); -} - -Accessibility::TableCell::RowColumnSpanType NUIViewAccessible::GetCellRowColumnSpan() const -{ - Accessibility::TableCell::RowColumnSpanType span{}; - - std::tie(span.row, span.column) = GetCellPosition(); - span.rowSpan = GetCellRowSpan(); - span.columnSpan = GetCellColumnSpan(); - - return span; -} - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Accessibility_DuplicateString(const char* arg) -{ - return strdup(arg); -} - -SWIGEXPORT IntPairType* SWIGSTDCALL CSharp_Dali_Accessibility_MakeIntPair(int first, int second) -{ - return new IntPairType(first, second); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_SetAccessibilityDelegate(const void* arg1_accessibilityDelegate, uint32_t arg2_accessibilityDelegateSize) -{ - GUARD_ON_NULL_RET(arg1_accessibilityDelegate); - - const auto* accessibilityDelegate = static_cast(arg1_accessibilityDelegate); - auto accessibilityDelegateSize = static_cast(arg2_accessibilityDelegateSize); - - try_catch(([&]() { - if(accessibilityDelegateSize != sizeof(*accessibilityDelegate)) - { - DALI_LOG_ERROR("SetAccessibilityDelegate error: Marshal.SizeOf()[%zu] != sizeof(AccessibilityDelegate)[%zu]\n", accessibilityDelegateSize, sizeof(*accessibilityDelegate)); - throw std::runtime_error("SetAccessibilityDelegate error: Marshal.SizeOf() != sizeof(AccessibilityDelegate)"); - } - - NUIViewAccessible::SetAccessibilityDelegate(accessibilityDelegate); - Accessibility::Bridge::GetCurrentBridge()->SetToolkitName("nui(dali)"); - })); -} - -#ifdef __cplusplus -} // extern "C" -#endif diff --git a/dali-csharp-binder/src/nui-view-accessible.h b/dali-csharp-binder/src/nui-view-accessible.h deleted file mode 100644 index 0582a531..00000000 --- a/dali-csharp-binder/src/nui-view-accessible.h +++ /dev/null @@ -1,252 +0,0 @@ -/* - * Copyright (c) 2023 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. - * - */ - -#ifndef NUI_VIEW_ACCESSIBLE_H -#define NUI_VIEW_ACCESSIBLE_H - -// EXTERNAL INCLUDES -#include -#include -#include -#include -#include -#include -#include -#include - -class NUIViewAccessible : public Dali::Toolkit::DevelControl::ControlAccessible, - public virtual Dali::Accessibility::EditableText, // includes Text - public virtual Dali::Accessibility::Selection, - public virtual Dali::Accessibility::Value, - public virtual Dali::Accessibility::Table, - public virtual Dali::Accessibility::TableCell - -{ -public: - struct AccessibilityDelegate; // Forward declaration - - using IntPairType = std::pair; - using IntVectorType = std::vector; - - NUIViewAccessible() = delete; - NUIViewAccessible(const NUIViewAccessible&) = delete; - NUIViewAccessible(NUIViewAccessible&&) = delete; - - NUIViewAccessible& operator=(const NUIViewAccessible&) = delete; - NUIViewAccessible& operator=(NUIViewAccessible&&) = delete; - - NUIViewAccessible(Dali::Actor actor); - - static void SetAccessibilityDelegate(const AccessibilityDelegate* accessibilityDelegate); - - // Standard interfaces (Accessible, Action, Component) - - std::string GetNameRaw() const override; - - std::string GetDescriptionRaw() const override; - - bool GrabHighlight() override; - - std::string GetActionName(std::size_t index) const override; - - std::size_t GetActionCount() const override; - - bool DoAction(std::size_t index) override; - - bool DoAction(const std::string& name) override; - - Dali::Accessibility::States CalculateStates() override; - - Dali::Accessibility::Attributes GetAttributes() const override; - - Dali::Property::Index GetNamePropertyIndex() override; - - Dali::Property::Index GetDescriptionPropertyIndex() override; - - bool IsScrollable() const override; - - bool ScrollToChild(Dali::Actor child) override; - - Dali::Accessibility::AtspiInterfaces DoGetInterfaces() const override; - - // Value interface - - double GetMinimum() const override; - - double GetCurrent() const override; - - std::string GetValueText() const override; - - double GetMaximum() const override; - - bool SetCurrent(double value) override; - - double GetMinimumIncrement() const override; - - // Text interface - - std::string GetText(std::size_t startOffset, std::size_t endOffset) const override; - - std::size_t GetCharacterCount() const override; - - std::size_t GetCursorOffset() const override; - - bool SetCursorOffset(std::size_t offset) override; - - Dali::Accessibility::Range GetTextAtOffset(std::size_t offset, Dali::Accessibility::TextBoundary boundary) const override; - - Dali::Accessibility::Range GetRangeOfSelection(std::size_t selectionIndex) const override; - - bool RemoveSelection(std::size_t selectionIndex) override; - - bool SetRangeOfSelection(std::size_t selectionIndex, std::size_t startOffset, std::size_t endOffset) override; - - Dali::Rect<> GetRangeExtents(std::size_t startOffset, std::size_t endOffset, Dali::Accessibility::CoordinateType type) override; - - // EditableText interface - - bool CopyText(std::size_t startPosition, std::size_t endPosition) override; - - bool CutText(std::size_t startPosition, std::size_t endPosition) override; - - bool InsertText(std::size_t startPosition, std::string text) override; - - bool SetTextContents(std::string newContents) override; - - bool DeleteText(std::size_t startPosition, std::size_t endPosition) override; - - // Selection interface - - int GetSelectedChildrenCount() const override; - - Dali::Accessibility::Accessible* GetSelectedChild(int selectedChildIndex) override; - - bool SelectChild(int childIndex) override; - - bool DeselectSelectedChild(int selectedChildIndex) override; - - bool IsChildSelected(int childIndex) const override; - - bool SelectAll() override; - - bool ClearSelection() override; - - bool DeselectChild(int childIndex) override; - - // Table interface - - int GetRowCount() const override; - - int GetColumnCount() const override; - - int GetSelectedRowCount() const override; - - int GetSelectedColumnCount() const override; - - Dali::Accessibility::Accessible* GetCaption() const override; - - Dali::Accessibility::Accessible* GetSummary() const override; - - Dali::Accessibility::TableCell* GetCell(int row, int column) const override; - - std::size_t GetChildIndex(int row, int column) const override; - - // Non-virtual helper. Inverse of GetChildIndex(). - IntPairType GetPositionByChildIndex(std::size_t childIndex) const; - - int GetRowByChildIndex(std::size_t childIndex) const override; - - int GetColumnByChildIndex(std::size_t childIndex) const override; - - std::string GetRowDescription(int row) const override; - - std::string GetColumnDescription(int column) const override; - - int GetRowSpan(int row, int column) const override; - - int GetColumnSpan(int row, int column) const override; - - Dali::Accessibility::Accessible* GetRowHeader(int row) const override; - - Dali::Accessibility::Accessible* GetColumnHeader(int column) const override; - - IntVectorType GetSelectedRows() const override; - - IntVectorType GetSelectedColumns() const override; - - bool IsRowSelected(int row) const override; - - bool IsColumnSelected(int column) const override; - - bool IsCellSelected(int row, int column) const override; - - bool AddRowSelection(int row) override; - - bool AddColumnSelection(int column) override; - - bool RemoveRowSelection(int row) override; - - bool RemoveColumnSelection(int column) override; - - Dali::Accessibility::Table::RowColumnSpanType GetRowColumnSpan(std::size_t childIndex) const override; - - // TableCell interface - - Dali::Accessibility::Table* GetTable() const override; - - IntPairType GetCellPosition() const override; - - int GetCellRowSpan() const override; - - int GetCellColumnSpan() const override; - - Dali::Accessibility::TableCell::RowColumnSpanType GetCellRowColumnSpan() const override; - -private: - // Points to memory managed from the C# side - static inline const AccessibilityDelegate* mTable = nullptr; - - // Frees memory allocated in C# via a call to CSharp_Dali_Accessibility_DuplicateString - static std::string StealString(char* str); - - // Frees memory allocated in C# via a call to an interop that calls 'operator new' - template - static T StealObject(T* obj); - - /** - * @brief Safely calls a virtual C# method through AccessibilityDelegate. - * - * This verifies that the specified function pointer is not null and that - * the specified interface is implemented by the target object. This is due - * to the fact that dynamic_cast can see more interfaces than this object - * is meant to represent (dynamic_cast cannot be used to examine C# objects, - * so we have to rely on a set of AtspiInterfaces returned by GetInterfaces). - * - * @tparam I The interface that the method belongs to - * @tparam R The return type of the method (deduced automatically) - * @tparam Args The parameter types of the method (deduced automatically) - * - * @param method The method (function pointer from AccessibilityDelegate) - * @param args Method arguments - * - * @return Value returned by the chosen method - */ - template - R CallMethod(R (*method)(Dali::RefObject*, Args...), Args... args) const; -}; - -#endif // NUI_VIEW_ACCESSIBLE_H diff --git a/dali-csharp-binder/src/processor-controller.cpp b/dali-csharp-binder/src/processor-controller.cpp deleted file mode 100644 index d8d699b4..00000000 --- a/dali-csharp-binder/src/processor-controller.cpp +++ /dev/null @@ -1,186 +0,0 @@ -/* - * Copyright (c) 2021 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. - * - */ - -// CLASS HEADER -#include "processor-controller.h" - -// EXTERNAL INCLUDES -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -ProcessorController::ProcessorController() -: mHandler(nullptr), - mPostHandler(nullptr), - mKeepRenderingApplied(false) -{ - { - try - { - Dali::Adaptor::Get().RegisterProcessor(*this); - Dali::Adaptor::Get().RegisterProcessor(*this, true); - } - CALL_CATCH_EXCEPTION(); - } -} - -ProcessorController::~ProcessorController() -{ - { - try - { - Dali::Adaptor::Get().UnregisterProcessor(*this); - Dali::Adaptor::Get().UnregisterProcessor(*this, true); - } - CALL_CATCH_EXCEPTION(); - } -} - -void ProcessorController::Process(bool postProcessor) -{ - if(!postProcessor) - { - // We will ignore Awake events during Process running - mKeepRenderingApplied = true; - if(DALI_LIKELY(mHandler != nullptr)) - { - mHandler(); - } - } - else - { - if(DALI_LIKELY(mPostHandler != nullptr)) - { - mPostHandler(); - } - // Make awake events can be applied after PostProcess done. - mKeepRenderingApplied = false; - } -} - -void ProcessorController::SetCallback( ProcessorControllerProcessCallback callback ) -{ - mHandler = callback; -} - -void ProcessorController::SetPostCallback( ProcessorControllerProcessCallback postCallback ) -{ - mPostHandler = postCallback; -} - -void ProcessorController::RemoveCallback( ProcessorControllerProcessCallback callback ) -{ - mHandler = nullptr; -} -void ProcessorController::RemovePostCallback( ProcessorControllerProcessCallback postCallback ) -{ - mPostHandler = nullptr; -} - -void ProcessorController::Awake() -{ - if(DALI_UNLIKELY(!mKeepRenderingApplied)) - { - if(DALI_LIKELY(Dali::Stage::IsInstalled())) - { - auto stage = Dali::Stage::GetCurrent(); - stage.KeepRendering(0.0f); - mKeepRenderingApplied = true; - } - } -} - -// ProcessorController Bindings -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProcessorController() { - - ProcessorController *result = 0 ; - - { - try { - result = (ProcessorController *)new ProcessorController(); - } CALL_CATCH_EXCEPTION(0); - } - - return (void *)result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProcessorController(void * jarg1) { - - ProcessorController * arg1 = (ProcessorController *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProcessorController_SetCallback( void* jarg1, ProcessorController::ProcessorControllerProcessCallback callback ) -{ - ProcessorController* processorController = (ProcessorController *) jarg1; - - if( processorController ) - { - processorController->SetCallback( callback ); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProcessorController_SetPostCallback( void* jarg1, ProcessorController::ProcessorControllerProcessCallback callback ) -{ - ProcessorController* processorController = (ProcessorController *) jarg1; - - if( processorController ) - { - processorController->SetPostCallback( callback ); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProcessorController_RemoveCallback( void* jarg1, ProcessorController::ProcessorControllerProcessCallback callback ) -{ - ProcessorController* processorController = (ProcessorController *) jarg1; - - if( processorController ) - { - processorController->RemoveCallback( callback ); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProcessorController_RemovePostCallback( void* jarg1, ProcessorController::ProcessorControllerProcessCallback callback ) -{ - ProcessorController* processorController = (ProcessorController *) jarg1; - - if( processorController ) - { - processorController->RemovePostCallback( callback ); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProcessorController_Awake( void* jarg1 ) -{ - ProcessorController* processorController = (ProcessorController *) jarg1; - - if( processorController ) - { - processorController->Awake(); - } -} - -#ifdef __cplusplus -} -#endif \ No newline at end of file diff --git a/dali-csharp-binder/src/processor-controller.h b/dali-csharp-binder/src/processor-controller.h deleted file mode 100644 index 25ab9946..00000000 --- a/dali-csharp-binder/src/processor-controller.h +++ /dev/null @@ -1,94 +0,0 @@ -#ifndef CSHARP_PROCESSOR_CONTROLLER_H -#define CSHARP_PROCESSOR_CONTROLLER_H - -/* - * Copyright (c) 2021 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -/** - * @brief Implements a Integration::Processor interface so can be registered with dali-core as - * a Processor. Enables the setting of a callback so dali-core can execute this callback when - * Process() is run. - */ -class ProcessorController : public Dali::Integration::Processor -{ -public: - - // Function pointer matching delegate in C# ProcessorController - using ProcessorControllerProcessCallback = void (SWIGSTDCALL*)(); - -public: - /** - * @brief Constructor - creates a ProcessorController and registers it with dali-core. - * - */ - ProcessorController(); - - /** - * @brief Destructor - Unregisters itself from dali-core. - */ - ~ProcessorController(); - - /** - * @copydoc Dali::Integration::Processor::Process() - */ - void Process(bool postProcessor) override; - - /** - * @brief Set the callback to be executed when dali-core calls the overriden Process() api. - * @param[in] callback, function to be called - */ - void SetCallback( ProcessorControllerProcessCallback callback ); - - /** - * @brief Set the postcallback to be executed when dali-core calls the overriden Process(true) api. - * @param[in] postCallback, function to be called - */ - void SetPostCallback( ProcessorControllerProcessCallback postCallback ); - - /** - * @brief Remove callback on this ProcessorController. - * The removed callback will not be called anymore. - * @param[in] callback, function will be removed - */ - void RemoveCallback( ProcessorControllerProcessCallback callback ); - - /** - * @brief Remove postcallback on this ProcessorController. - * The removed callback will not be called anymore. - * @param[in] postCallback, function will be removed - */ - void RemovePostCallback( ProcessorControllerProcessCallback postCallback ); - - /** - * @brief Awake update thread so dali-core calls the overriden Process() api. - */ - void Awake(); - -private: - - ProcessorControllerProcessCallback mHandler; ///< PreProcessHandler before Relayout - ProcessorControllerProcessCallback mPostHandler; ///< PostProcessHandler after Relayout - bool mKeepRenderingApplied; ///< True if we call Stage::KeepRendering(0.0f). It need to avoid duplicated keep rendering call -}; - -#endif // CSHARP_PROCESSOR_CONTROLLER_H \ No newline at end of file diff --git a/dali-csharp-binder/src/rive-animation-view-wrap.cpp b/dali-csharp-binder/src/rive-animation-view-wrap.cpp deleted file mode 100644 index 2dd57d6d..00000000 --- a/dali-csharp-binder/src/rive-animation-view-wrap.cpp +++ /dev/null @@ -1,424 +0,0 @@ -/* - * Copyright (c) 2021 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -using namespace Dali; -using namespace Dali::Toolkit; -using namespace Dali::Extension; - -#ifdef __cplusplus -extern "C" { -#endif - -static const char *nullExceptMsg = "Attempt to dereference null Dali::Extension::RiveAnimationView"; - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_RiveAnimationView_New__SWIG_0(char * jarg1) { - void *jresult = nullptr; - RiveAnimationView result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - { - try { - result = RiveAnimationView::New(arg1_str); - jresult = new Dali::Extension::RiveAnimationView((const Dali::Extension::RiveAnimationView &)result); - } CALL_CATCH_EXCEPTION(0); - } - - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RiveAnimationView_EnableAnimation(char * jarg1, char * jarg2, bool jarg3) { - RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; - - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); - return; - } - std::string arg2_str(jarg2); - { - try { - arg1->EnableAnimation(arg2_str, jarg3); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RiveAnimationView_PlayAnimation(char * jarg1) { - RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; - - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return; - } - { - try { - arg1->PlayAnimation(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RiveAnimationView_PauseAnimation(char * jarg1) { - RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; - - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return; - } - { - try { - arg1->PauseAnimation(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RiveAnimationView_StopAnimation(char * jarg1) { - RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; - - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return; - } - { - try { - arg1->StopAnimation(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void CSharp_Dali_RiveAnimationView_SetShapeFillColor(char * jarg1, char * jarg2, char * jarg3) -{ - Dali::Vector4 *arg3 = nullptr; - - RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); - return; - } - std::string arg2_str(jarg2); - arg3 = (Dali::Vector4 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return; - } - arg3->a *= 255.f; - arg3->r *= 255.f; - arg3->g *= 255.f; - arg3->b *= 255.f; - { - try { - arg1->SetShapeFillColor(arg2_str, *arg3); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void CSharp_Dali_RiveAnimationView_SetShapeStrokeColor(char * jarg1, char * jarg2, char * jarg3) -{ - Dali::Vector4 *arg3 = nullptr; - - RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); - return; - } - std::string arg2_str(jarg2); - arg3 = (Dali::Vector4 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0); - return; - } - arg3->a *= 255.f; - arg3->r *= 255.f; - arg3->g *= 255.f; - arg3->b *= 255.f; - { - try { - arg1->SetShapeStrokeColor(arg2_str, *arg3); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void CSharp_Dali_RiveAnimationView_SetNodeOpacity(char * jarg1, char * jarg2, float jarg3) -{ - RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; - - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); - return; - } - std::string arg2_str(jarg2); - { - try { - arg1->SetNodeOpacity(arg2_str, jarg3); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void CSharp_Dali_RiveAnimationView_SetNodeScale(char * jarg1, char * jarg2, char * jarg3) -{ - Dali::Vector2 *arg3 = nullptr; - - RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); - return; - } - std::string arg2_str(jarg2); - arg3 = (Dali::Vector2 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return; - } - { - try { - arg1->SetNodeScale(arg2_str, *arg3); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void CSharp_Dali_RiveAnimationView_SetNodeRotation(char * jarg1, char * jarg2, char * jarg3) -{ - Dali::Degree *arg3 = nullptr; - - RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); - return; - } - std::string arg2_str(jarg2); - arg3 = (Dali::Degree *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0); - return; - } - { - try { - arg1->SetNodeRotation(arg2_str, *arg3); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void CSharp_Dali_RiveAnimationView_SetNodePosition(char * jarg1, char * jarg2, char * jarg3) -{ - Dali::Vector2 *arg3 = nullptr; - - RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); - return; - } - std::string arg2_str(jarg2); - arg3 = (Dali::Vector2 *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return; - } - { - try { - arg1->SetNodePosition(arg2_str, *arg3); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void CSharp_Dali_RiveAnimationView_PointerMove(char * jarg1, float jarg2, float jarg3) -{ - RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return; - } - { - try { - arg1->PointerMove(jarg2, jarg3); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void CSharp_Dali_RiveAnimationView_PointerDown(char * jarg1, float jarg2, float jarg3) -{ - RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return; - } - { - try { - arg1->PointerDown(jarg2, jarg3); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void CSharp_Dali_RiveAnimationView_PointerUp(char * jarg1, float jarg2, float jarg3) -{ - RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return; - } - { - try { - arg1->PointerUp(jarg2, jarg3); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool CSharp_Dali_RiveAnimationView_SetNumberState(char * jarg1, char * jarg2, char * jarg3, float jarg4) -{ - RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return false; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); - return false; - } - std::string arg2_str(jarg2); - if (!jarg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg3 is null string", 0); - return false; - } - std::string arg3_str(jarg3); - { - try { - return arg1->SetNumberState(arg2_str, arg3_str, jarg4); - } - CALL_CATCH_EXCEPTION(false); - } -} - -SWIGEXPORT bool CSharp_Dali_RiveAnimationView_SetBooleanState(char * jarg1, char * jarg2, char * jarg3, bool jarg4) -{ - RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return false; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); - return false; - } - std::string arg2_str(jarg2); - if (!jarg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg3 is null string", 0); - return false; - } - std::string arg3_str(jarg3); - { - try { - return arg1->SetBooleanState(arg2_str, arg3_str, jarg4); - } - CALL_CATCH_EXCEPTION(false); - } -} - -SWIGEXPORT bool CSharp_Dali_RiveAnimationView_FireState(char * jarg1, char * jarg2, char * jarg3) -{ - RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return false; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); - return false; - } - std::string arg2_str(jarg2); - if (!jarg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg3 is null string", 0); - return false; - } - std::string arg3_str(jarg3); - { - try { - return arg1->FireState(arg2_str, arg3_str); - } - CALL_CATCH_EXCEPTION(false); - } -} - -SWIGEXPORT void CSharp_Dali_RiveAnimationView_SetAnimationElapsedTime(char * jarg1, char * jarg2, float jarg3) -{ - RiveAnimationView *arg1 = (RiveAnimationView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, nullExceptMsg, 0); - return; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); - return; - } - std::string arg2_str(jarg2); - { - try { - arg1->SetAnimationElapsedTime(arg2_str, jarg3); - } - CALL_CATCH_EXCEPTION(); - } -} - -#ifdef __cplusplus -} // end extern "C" -#endif diff --git a/dali-csharp-binder/src/rotation-wrap.cpp b/dali-csharp-binder/src/rotation-wrap.cpp deleted file mode 100644 index 7c941552..00000000 --- a/dali-csharp-binder/src/rotation-wrap.cpp +++ /dev/null @@ -1,988 +0,0 @@ -/* - * Copyright (c) 2023 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Rotation_0() -{ - void* jresult; - Dali::Quaternion* result = 0; - - { - try - { - result = (Dali::Quaternion*)new Dali::Quaternion(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Rotation_1(void* nuiRadianAngle, void* nuiVector3) -{ - void* jresult; - Dali::Radian* radian = (Dali::Radian*)nuiRadianAngle; - Dali::Vector3* vector = (Dali::Vector3*)nuiVector3; - Dali::Quaternion* result = 0; - - if(!radian) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0); - return 0; - } - if(!vector) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Quaternion*)new Dali::Quaternion(*radian, (Dali::Vector3 const&)*vector); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Rotation_2(void* nuiV0, void* nuiV1) -{ - void* jresult; - Dali::Vector3* v0 = (Dali::Vector3*)nuiV0; - Dali::Vector3* v1 = (Dali::Vector3*)nuiV1; - Dali::Quaternion* result = 0; - - if(!v0) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - if(!v1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Quaternion*)new Dali::Quaternion((Dali::Vector3 const&)*v0, (Dali::Vector3 const&)*v1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Rotation_3(void* nuiPitchRadian, void* nuiYawRadian, void* nuiRollRadian) -{ - void* jresult; - Dali::Radian* pitch = (Dali::Radian*)nuiPitchRadian; - Dali::Radian* yaw = (Dali::Radian*)nuiYawRadian; - Dali::Radian* roll = (Dali::Radian*)nuiRollRadian; - Dali::Quaternion* result = 0; - - if(!pitch) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type pitch is null", 0); - return 0; - } - if(!yaw) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type yaw is null", 0); - return 0; - } - if(!roll) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type roll is null", 0); - return 0; - } - { - try - { - result = (Dali::Quaternion*)new Dali::Quaternion((Dali::Radian const&)*pitch, (Dali::Radian const&)*yaw, (Dali::Radian const&)*roll); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Rotation_4(void* nuiVector4) -{ - void* jresult; - Dali::Vector4* vector4 = (Dali::Vector4*)nuiVector4; - Dali::Quaternion* result = 0; - - if(!vector4) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type vector4 is null", 0); - return 0; - } - { - try - { - result = (Dali::Quaternion*)new Dali::Quaternion((Dali::Vector4 const&)*vector4); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void* nuiRotation) -{ - Dali::Quaternion* quaternion = (Dali::Quaternion*)0; - - quaternion = (Dali::Quaternion*)nuiRotation; - { - try - { - delete quaternion; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() -{ - void* jresult; - Dali::Quaternion* result = 0; - - result = (Dali::Quaternion*)&Dali::Quaternion::IDENTITY; - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void* nuiRotation) -{ - bool result; - Dali::Quaternion* quaternion = (Dali::Quaternion*)0; - - quaternion = (Dali::Quaternion*)nuiRotation; - { - try - { - result = (bool)((Dali::Quaternion const*)quaternion)->IsIdentity(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void* nuiRotation, void* nuiAxis, void* nuiRadianAngle) -{ - bool result; - Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; - Dali::Vector3* axis = (Dali::Vector3*)nuiAxis; - Dali::Radian* radian = (Dali::Radian*)nuiRadianAngle; - - if(!axis) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0); - return 0; - } - if(!radian) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0); - return 0; - } - { - try - { - result = (bool)((Dali::Quaternion const*)quaternion)->ToAxisAngle(*axis, *radian); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_SetEulerAngle(void* nuiRotation, void* nuiPitchRadian, void* nuiYawRadian, void* nuiRollRadian) -{ - Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; - Dali::Radian* pitch = (Dali::Radian*)nuiPitchRadian; - Dali::Radian* yaw = (Dali::Radian*)nuiYawRadian; - Dali::Radian* roll = (Dali::Radian*)nuiRollRadian; - - if(!pitch) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type pitch is null", 0); - return; - } - if(!yaw) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type yaw is null", 0); - return; - } - if(!roll) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type roll is null", 0); - return; - } - { - try - { - ((Dali::Quaternion*)quaternion)->SetEuler((Dali::Radian const&)*pitch, (Dali::Radian const&)*yaw, (Dali::Radian const&)*roll); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_GetEulerAngle(void* nuiRotation, void* nuiPitchRadian, void* nuiYawRadian, void* nuiRollRadian) -{ - Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; - Dali::Radian* pitch = (Dali::Radian*)nuiPitchRadian; - Dali::Radian* yaw = (Dali::Radian*)nuiYawRadian; - Dali::Radian* roll = (Dali::Radian*)nuiRollRadian; - - if(!pitch) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type pitch is null", 0); - return; - } - if(!yaw) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type yaw is null", 0); - return; - } - if(!roll) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type roll is null", 0); - return; - } - { - try - { - Dali::Vector4 result = (Dali::Vector4)((Dali::Quaternion const*)quaternion)->EulerAngles(); - // Convert from EulerAngles to pitch / yaw / roll - *pitch = Dali::Radian(result.x); - *yaw = Dali::Radian(result.y); - *roll = Dali::Radian(result.z); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Add(void* nuiRotation0, void* nuiRotation1) -{ - void* jresult; - Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; - Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; - Dali::Quaternion result; - - if(!quaternion1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - { - try - { - result = ((Dali::Quaternion const*)quaternion0)->operator+((Dali::Quaternion const&)*quaternion1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Quaternion((const Dali::Quaternion&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Subtract_0(void* nuiRotation0, void* nuiRotation1) -{ - void* jresult; - Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; - Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; - Dali::Quaternion result; - - if(!quaternion1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - { - try - { - result = ((Dali::Quaternion const*)quaternion0)->operator-((Dali::Quaternion const&)*quaternion1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Quaternion((const Dali::Quaternion&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Multiply_0(void* nuiRotation0, void* nuiRotation1) -{ - void* jresult; - Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; - Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; - Dali::Quaternion result; - - if(!quaternion1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - { - try - { - result = ((Dali::Quaternion const*)quaternion0)->operator*((Dali::Quaternion const&)*quaternion1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Quaternion((const Dali::Quaternion&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Multiply_1(void* nuiRotation, void* nuiVector3) -{ - void* jresult; - Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; - Dali::Vector3* vector = (Dali::Vector3*)nuiVector3; - Dali::Vector3 result; - - if(!vector) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0); - return 0; - } - { - try - { - result = ((Dali::Quaternion const*)quaternion)->operator*((Dali::Vector3 const&)*vector); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Divide_0(void* nuiRotation0, void* nuiRotation1) -{ - void* jresult; - Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; - Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; - Dali::Quaternion result; - - if(!quaternion1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - { - try - { - result = ((Dali::Quaternion const*)quaternion0)->operator/((Dali::Quaternion const&)*quaternion1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Quaternion((const Dali::Quaternion&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Multiply_2(void* nuiRotation, float scale) -{ - void* jresult; - Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; - Dali::Quaternion result; - { - try - { - result = ((Dali::Quaternion const*)quaternion)->operator*(scale); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Quaternion((const Dali::Quaternion&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Divide_1(void* nuiRotation, float scale) -{ - void* jresult; - Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; - Dali::Quaternion result; - { - try - { - result = ((Dali::Quaternion const*)quaternion)->operator/(scale); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Quaternion((const Dali::Quaternion&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Subtract_1(void* nuiRotation) -{ - void* jresult; - Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; - Dali::Quaternion result; - - { - try - { - result = ((Dali::Quaternion const*)quaternion)->operator-(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Quaternion((const Dali::Quaternion&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void* nuiRotation0, void* nuiRotation1) -{ - void* jresult; - Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; - Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; - Dali::Quaternion* result = 0; - - if(!quaternion1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Quaternion*)&(quaternion0)->operator+=((Dali::Quaternion const&)*quaternion1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void* nuiRotation0, void* nuiRotation1) -{ - void* jresult; - Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; - Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; - Dali::Quaternion* result = 0; - - if(!quaternion1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Quaternion*)&(quaternion0)->operator-=((Dali::Quaternion const&)*quaternion1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign_0(void* nuiRotation0, void* nuiRotation1) -{ - void* jresult; - Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; - Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; - Dali::Quaternion* result = 0; - - if(!quaternion1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Quaternion*)&(quaternion0)->operator*=((Dali::Quaternion const&)*quaternion1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign_1(void* nuiRotation, float scale) -{ - void* jresult; - Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; - Dali::Quaternion* result; - { - try - { - result = (Dali::Quaternion*)&(quaternion)->operator*=(scale); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void* nuiRotation, float scale) -{ - void* jresult; - Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; - Dali::Quaternion* result; - { - try - { - result = (Dali::Quaternion*)&(quaternion)->operator/=(scale); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void*)result; - return jresult; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void* nuiRotation0, void* nuiRotation1) -{ - bool result; - Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; - Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; - - if(!quaternion1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - { - try - { - result = (bool)((Dali::Quaternion const*)quaternion0)->operator==((Dali::Quaternion const&)*quaternion1); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void* nuiRotation0, void* nuiRotation1) -{ - bool result; - Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; - Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; - - if(!quaternion1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - { - try - { - result = (bool)((Dali::Quaternion const*)quaternion0)->operator!=((Dali::Quaternion const&)*quaternion1); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void* nuiRotation) -{ - float result; - Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; - - { - try - { - result = (float)((Dali::Quaternion const*)quaternion)->Length(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void* nuiRotation) -{ - float result; - Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; - - { - try - { - result = (float)((Dali::Quaternion const*)quaternion)->LengthSquared(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void* nuiRotation) -{ - Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; - - { - try - { - (quaternion)->Normalize(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void* nuiRotation) -{ - void* jresult; - Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; - Dali::Quaternion result; - - { - try - { - result = ((Dali::Quaternion const*)quaternion)->Normalized(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Quaternion((const Dali::Quaternion&)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void* nuiRotation) -{ - Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; - - { - try - { - (quaternion)->Conjugate(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void* nuiRotation) -{ - Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; - - { - try - { - (quaternion)->Invert(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Log(void* nuiRotation) -{ - void* jresult; - Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; - Dali::Quaternion result; - - { - try - { - result = ((Dali::Quaternion const*)quaternion)->Log(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Quaternion((const Dali::Quaternion&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Exp(void* nuiRotation) -{ - void* jresult; - Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; - Dali::Quaternion result; - - { - try - { - result = ((Dali::Quaternion const*)quaternion)->Exp(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Quaternion((const Dali::Quaternion&)result); - return jresult; -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void* nuiRotation0, void* nuiRotation1) -{ - float result; - Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; - Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; - - if(!quaternion0) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - if(!quaternion1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - { - try - { - result = (float)Dali::Quaternion::Dot((Dali::Quaternion const&)*quaternion0, (Dali::Quaternion const&)*quaternion1); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void* nuiRotation0, void* nuiRotation1, float progress) -{ - void* jresult; - Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; - Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; - Dali::Quaternion result; - - if(!quaternion0) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - if(!quaternion1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - - { - try - { - result = Dali::Quaternion::Lerp((Dali::Quaternion const&)*quaternion0, (Dali::Quaternion const&)*quaternion1, progress); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Quaternion((const Dali::Quaternion&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void* nuiRotation0, void* nuiRotation1, float progress) -{ - void* jresult; - Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; - Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; - Dali::Quaternion result; - - if(!quaternion0) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - if(!quaternion1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - - { - try - { - result = Dali::Quaternion::Slerp((Dali::Quaternion const&)*quaternion0, (Dali::Quaternion const&)*quaternion1, progress); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Quaternion((const Dali::Quaternion&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void* nuiRotation0, void* nuiRotation1, float progress) -{ - void* jresult; - Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; - Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; - Dali::Quaternion result; - - if(!quaternion0) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - if(!quaternion1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - - { - try - { - result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const&)*quaternion0, (Dali::Quaternion const&)*quaternion1, progress); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Quaternion((const Dali::Quaternion&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Squad(void* nuiStart, void* nuiEnd, void* nuiControl0, void* nuiControl1, float progress) -{ - void* jresult; - Dali::Quaternion* start = (Dali::Quaternion*)nuiStart; - Dali::Quaternion* end = (Dali::Quaternion*)nuiEnd; - Dali::Quaternion* control0 = (Dali::Quaternion*)nuiControl0; - Dali::Quaternion* control1 = (Dali::Quaternion*)nuiControl1; - Dali::Quaternion result; - - if(!start) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - if(!end) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - if(!control0) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - if(!control1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - { - try - { - result = Dali::Quaternion::Squad((Dali::Quaternion const&)*start, (Dali::Quaternion const&)*end, (Dali::Quaternion const&)*control0, (Dali::Quaternion const&)*control1, progress); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Quaternion((const Dali::Quaternion&)result); - return jresult; -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void* nuiRotation0, void* nuiRotation1) -{ - float result; - Dali::Quaternion* quaternion0 = (Dali::Quaternion*)nuiRotation0; - Dali::Quaternion* quaternion1 = (Dali::Quaternion*)nuiRotation1; - - if(!quaternion0) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - if(!quaternion1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - { - try - { - result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const&)*quaternion0, (Dali::Quaternion const&)*quaternion1); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Rotate_Vector3(void* nuiRotation, void* nuiVector3) -{ - void* jresult; - Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; - Dali::Vector3* vector3 = (Dali::Vector3*)nuiVector3; - Dali::Vector3 result; - - if(!quaternion) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - if(!vector3) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - { - try - { - result = ((Dali::Quaternion const*)quaternion)->Rotate(*vector3); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector3((const Dali::Vector3&)result); - return jresult; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Rotation_Rotate_Vector4(void* nuiRotation, void* nuiVector4) -{ - void* jresult; - Dali::Quaternion* quaternion = (Dali::Quaternion*)nuiRotation; - Dali::Vector4* vector4 = (Dali::Vector4*)nuiVector4; - Dali::Vector4 result; - - if(!quaternion) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - if(!vector4) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0); - return 0; - } - { - try - { - result = ((Dali::Quaternion const*)quaternion)->Rotate(*vector4); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4&)result); - return jresult; -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/scale-transition-wrap.cpp b/dali-csharp-binder/src/scale-transition-wrap.cpp deleted file mode 100755 index e881da4b..00000000 --- a/dali-csharp-binder/src/scale-transition-wrap.cpp +++ /dev/null @@ -1,220 +0,0 @@ -/* - * Copyright (c) 2021 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_ScaleTransition() - { - void *jresult; - Dali::Toolkit::ScaleTransition *result = 0; - - { - try - { - result = (Dali::Toolkit::ScaleTransition *)new Dali::Toolkit::ScaleTransition(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_ScaleTransition_New_1(void *nuiControl, float scale, void *nuiTimePeriod) - { - void *jresult; - Dali::Toolkit::Control *control = (Dali::Toolkit::Control *)nuiControl; - Dali::TimePeriod *timePeriod = (Dali::TimePeriod *)nuiTimePeriod; - - Dali::Toolkit::ScaleTransition result; - - if (!control) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0); - return 0; - } - { - try - { - result = Dali::Toolkit::ScaleTransition::New(*control, scale, *timePeriod); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ScaleTransition((const Dali::Toolkit::ScaleTransition &)result); - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_ScaleTransition_New_2(void *nuiControl, void *nuiScale, void *nuiTimePeriod) - { - void *jresult; - Dali::Toolkit::Control *control = (Dali::Toolkit::Control *)nuiControl; - Dali::Vector2 *scale = (Dali::Vector2 *)nuiScale; - Dali::TimePeriod *timePeriod = (Dali::TimePeriod *)nuiTimePeriod; - - Dali::Toolkit::ScaleTransition result; - - if (!control) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0); - return 0; - } - if (!scale) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try - { - result = Dali::Toolkit::ScaleTransition::New(*control, *scale, *timePeriod); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ScaleTransition((const Dali::Toolkit::ScaleTransition &)result); - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScaleTransition(void *nuiScaleTransition) - { - Dali::Toolkit::ScaleTransition *scale = (Dali::Toolkit::ScaleTransition *)nuiScaleTransition; - - if (!scale) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0); - return; - } - { - try - { - delete scale; - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_ScaleTransition_Set(void *nuiScaleTransition) - { - Dali::Toolkit::ScaleTransition *newScaleTransition = 0; - Dali::Toolkit::ScaleTransition *scale = (Dali::Toolkit::ScaleTransition *)nuiScaleTransition; - - if (!scale) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScaleTransition const & type is null", 0); - return 0; - } - { - try - { - newScaleTransition = (Dali::Toolkit::ScaleTransition *)new Dali::Toolkit::ScaleTransition((Dali::Toolkit::ScaleTransition const &)*scale); - } - CALL_CATCH_EXCEPTION(0); - } - void *result; - result = (void *)newScaleTransition; - return result; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_ScaleTransition_Assign(void *nuiDestination, void *nuiSource) - { - void *jresult; - Dali::Toolkit::ScaleTransition *destination = (Dali::Toolkit::ScaleTransition *)nuiDestination; - Dali::Toolkit::ScaleTransition *source = (Dali::Toolkit::ScaleTransition *)nuiSource; - Dali::Toolkit::ScaleTransition *result = 0; - - if (!destination) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScaleTransition const & type is null", 0); - return 0; - } - if (!source) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScaleTransition const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Toolkit::ScaleTransition *)&(destination)->operator=((Dali::Toolkit::ScaleTransition const &)*source); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScaleTransition_SetScaleFactor(void *nuiScaleTransition, void *nuiScaleFactor) - { - Dali::Toolkit::ScaleTransition *scale = (Dali::Toolkit::ScaleTransition *)nuiScaleTransition; - Dali::Vector2 *scaleFactor = (Dali::Vector2 *)nuiScaleFactor; - - if (!scale) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScaleTransition const & type is null", 0); - return; - } - if (!scaleFactor) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return; - } - { - try - { - (scale)->SetScaleFactor((Dali::Vector2 const &)*scaleFactor); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_ScaleTransition_GetScaleFactor(void *nuiScaleTransition) - { - void *jresult; - Dali::Toolkit::ScaleTransition *scale = (Dali::Toolkit::ScaleTransition *)nuiScaleTransition; - Dali::Vector2 result; - - if (!scale) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScaleTransition const & type is null", 0); - return 0; - } - { - try - { - result = (scale)->GetScaleFactor(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; - } - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/scene-view-wrap.cpp b/dali-csharp-binder/src/scene-view-wrap.cpp deleted file mode 100755 index de7e5305..00000000 --- a/dali-csharp-binder/src/scene-view-wrap.cpp +++ /dev/null @@ -1,562 +0,0 @@ -/* - * Copyright (c) 2023 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SceneView_New_SWIG_0() - { - Dali::Scene3D::SceneView result; - { - try - { - result = Dali::Scene3D::SceneView::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::SceneView((const Dali::Scene3D::SceneView &)result); - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_SceneView_SWIG_0() - { - Dali::Scene3D::SceneView *result = 0; - - { - try - { - result = (Dali::Scene3D::SceneView *)new Dali::Scene3D::SceneView(); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void *)result; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_SceneView_SWIG_1(void *csSceneView) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - Dali::Scene3D::SceneView *result = 0; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::SceneView const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::SceneView *)new Dali::Scene3D::SceneView((Dali::Scene3D::SceneView const &)*sceneView); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void *)result; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SceneView(void *csSceneView) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - { - try - { - delete sceneView; - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SceneView_Assign(void *csDestination, void *csSource) - { - Dali::Scene3D::SceneView *destination = (Dali::Scene3D::SceneView *)csDestination; - Dali::Scene3D::SceneView *source = (Dali::Scene3D::SceneView *)csSource; - Dali::Scene3D::SceneView *result = 0; - - if (!source) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Scene3D::SceneView const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Scene3D::SceneView *)&(destination)->operator=((Dali::Scene3D::SceneView const &)*source); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void *)result; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SceneView_DownCast(void *csHandle) - { - Dali::BaseHandle *handle = (Dali::BaseHandle *)csHandle; - Dali::Scene3D::SceneView result; - - if (!handle) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return 0; - } - { - try - { - result = Dali::Scene3D::SceneView::DownCast(*handle); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Scene3D::SceneView((const Dali::Scene3D::SceneView &)result); - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_AddCamera(void *csSceneView, void *csCamera) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - Dali::CameraActor *cameraActor = (Dali::CameraActor *)csCamera; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return; - } - if (!cameraActor) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0); - return; - } - { - try - { - sceneView->AddCamera(*cameraActor); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_RemoveCamera(void *csSceneView, void *csCamera) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - Dali::CameraActor *cameraActor = (Dali::CameraActor *)csCamera; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return; - } - if (!cameraActor) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0); - return; - } - { - try - { - sceneView->RemoveCamera(*cameraActor); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_SceneView_GetCameraCount(void *csSceneView) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - uint32_t result = 0; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return 0; - } - { - try - { - result = sceneView->GetCameraCount(); - } - CALL_CATCH_EXCEPTION(0); - } - return result; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SceneView_GetSelectedCamera(void *csSceneView) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - Dali::CameraActor cameraActor; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return 0; - } - { - try - { - cameraActor = sceneView->GetSelectedCamera(); - } - CALL_CATCH_EXCEPTION(0); - } - Dali::CameraActor *result = new Dali::CameraActor((const Dali::CameraActor &)cameraActor); - return result; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SceneView_GetCamera_0(void *csSceneView, uint32_t index) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - Dali::CameraActor cameraActor; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return 0; - } - { - try - { - cameraActor = sceneView->GetCamera(index); - } - CALL_CATCH_EXCEPTION(0); - } - Dali::CameraActor *result = new Dali::CameraActor((const Dali::CameraActor &)cameraActor); - return result; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SceneView_GetCamera_1(void *csSceneView, char *name) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - Dali::CameraActor cameraActor; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return 0; - } - { - try - { - cameraActor = sceneView->GetCamera(std::string(name)); - } - CALL_CATCH_EXCEPTION(0); - } - Dali::CameraActor *result = new Dali::CameraActor((const Dali::CameraActor &)cameraActor); - return result; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_SelectCamera_0(void *csSceneView, uint32_t index) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return; - } - { - try - { - sceneView->SelectCamera(index); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_SelectCamera_1(void *csSceneView, char *name) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return; - } - { - try - { - sceneView->SelectCamera(std::string(name)); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_SetImageBasedLightSource(void *csSceneView, char *diffuseUrl, char *specularUrl, float scaleFactor) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return; - } - { - try - { - sceneView->SetImageBasedLightSource(std::string(diffuseUrl), std::string(specularUrl), scaleFactor); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_SetImageBasedLightScaleFactor(void *csSceneView, float scaleFactor) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return; - } - { - try - { - sceneView->SetImageBasedLightScaleFactor(scaleFactor); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT float SWIGSTDCALL CSharp_Dali_SceneView_GetImageBasedLightScaleFactor(void *csSceneView) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - float scaleFactor = 1.0f; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::ModelView", 0); - return scaleFactor; - } - { - try - { - scaleFactor = sceneView->GetImageBasedLightScaleFactor(); - } - CALL_CATCH_EXCEPTION(0.0f); - } - return scaleFactor; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_UseFramebuffer(void *csSceneView, bool useFramebuffer) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return; - } - { - try - { - sceneView->UseFramebuffer(useFramebuffer); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SceneView_IsUsingFramebuffer(void *csSceneView) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - bool result = false; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return false; - } - { - try - { - result = sceneView->IsUsingFramebuffer(); - } - CALL_CATCH_EXCEPTION(0); - } - return result; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_SetFramebufferMultiSamplingLevel(void *csSceneView, uint32_t multiSamplingLevel) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return; - } - { - try - { - sceneView->SetFramebufferMultiSamplingLevel(static_cast(multiSamplingLevel)); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_SceneView_GetFramebufferMultiSamplingLevel(void *csSceneView) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - uint32_t result = 0u; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return 0; - } - { - try - { - result = static_cast(sceneView->GetFramebufferMultiSamplingLevel()); - } - CALL_CATCH_EXCEPTION(0); - } - return result; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_SetSkybox(void *csSceneView, char *skyboxUrl) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return; - } - if (!skyboxUrl) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null string", 0); - return; - } - { - try - { - sceneView->SetSkybox(std::string(skyboxUrl)); - } - CALL_CATCH_EXCEPTION(); - } - return; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_SetSkyboxEnvironmentMapType(void *csSceneView, int skyboxEnvironmentMapType) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return; - } - { - try - { - sceneView->SetSkyboxEnvironmentMapType((Dali::Scene3D::EnvironmentMapType)skyboxEnvironmentMapType); - } - CALL_CATCH_EXCEPTION(); - } - return; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_SetSkyboxIntensity(void *csSceneView, float intensity) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return; - } - { - try - { - sceneView->SetSkyboxIntensity(intensity); - } - CALL_CATCH_EXCEPTION(); - } - return; - } - - SWIGEXPORT float SWIGSTDCALL CSharp_Dali_SceneView_GetSkyboxIntensity(void *csSceneView) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - float intensity = 1.0f; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return intensity; - } - { - try - { - intensity = sceneView->GetSkyboxIntensity(); - } - CALL_CATCH_EXCEPTION(0.0f); - } - return intensity; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SceneView_SetSkyboxOrientation(void *csSceneView, void *csOrientation) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - Dali::Quaternion *orientation = (Dali::Quaternion *)csOrientation; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return; - } - if (!orientation) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Quaternion", 0); - return; - } - { - try - { - sceneView->SetSkyboxOrientation(*orientation); - } - CALL_CATCH_EXCEPTION(); - } - return; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SceneView_GetSkyboxOrientation(void *csSceneView) - { - Dali::Scene3D::SceneView *sceneView = (Dali::Scene3D::SceneView *)csSceneView; - Dali::Quaternion orientation; - - if (!sceneView) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Scene3D::SceneView", 0); - return 0; - } - { - try - { - orientation = sceneView->GetSkyboxOrientation(); - } - CALL_CATCH_EXCEPTION(0); - } - Dali::Quaternion *result = new Dali::Quaternion((const Dali::Quaternion &)orientation); - return result; - } - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/signal-wrap.cpp b/dali-csharp-binder/src/signal-wrap.cpp deleted file mode 100644 index 15f5c491..00000000 --- a/dali-csharp-binder/src/signal-wrap.cpp +++ /dev/null @@ -1,203 +0,0 @@ -/* - * Copyright (c) 2021 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. - * - */ - -// INTERNAL INCLUDES -#include "control-devel-wrap.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* - * Implementation Signal is used in signals: - * AccessibilityGetName - * AccessibilityGetDescription - */ - -using StringToVoidFunc = void (*)(std::string &); -using StringToVoidSignal = Dali::Signal; - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Signal_StringToVoid_Empty(void *arg1) { - bool result = false; - GUARD_ON_NULL_RET0(arg1); - try_catch(([&]() { - auto object = (StringToVoidSignal*)arg1; - result = object->Empty(); - })); - return result; -} - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Signal_StringToVoid_GetConnectionCount(void *arg1) { - std::size_t result = 0; - GUARD_ON_NULL_RET0(arg1); - try_catch(([&]() { - auto object = (StringToVoidSignal*)arg1; - result = object->GetConnectionCount(); - })); - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Signal_StringToVoid_Connect(void *arg1, void *arg2) { - GUARD_ON_NULL_RET(arg1); - GUARD_ON_NULL_RET(arg2); - try_catch(([&]() { - auto object = (StringToVoidSignal*)arg1; - auto func = (StringToVoidFunc)arg2; - object->Connect(func); - })); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Signal_StringToVoid_Disconnect(void *arg1, void *arg2) { - GUARD_ON_NULL_RET(arg1); - GUARD_ON_NULL_RET(arg2); - try_catch(([&] () { - auto object = (StringToVoidSignal*)arg1; - auto func = (StringToVoidFunc)arg2; - object->Disconnect(func); - })); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Signal_StringToVoid_new() { - try_catch(([&]() { - return new StringToVoidSignal(); - })); - return nullptr; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Signal_StringToVoid_delete(void *arg1) { - GUARD_ON_NULL_RET(arg1); - try_catch(([&]() { - auto object = (StringToVoidSignal*)arg1; - delete object; - })); -} - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Signal_StringToVoid_GetResult(void *arg1) { - GUARD_ON_NULL_RET0(arg1); - std::string *data = (std::string*)arg1; - return SWIG_csharp_string_callback(data->c_str()); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Signal_StringToVoid_SetResult(void *arg1, char *arg2) { - GUARD_ON_NULL_RET(arg1); - GUARD_ON_NULL_RET(arg2); - try_catch(([&]() { - auto result = (std::string*)arg1; - (*result) = arg2; - })); -} - -/* - * Implementation Signal &)> is used in signals: - * AccessibilityDoGestureSignalType - */ - -using GesturePair = std::pair; -using GesturePairFunc = void (*)(GesturePair &); -using GesturePairSignal = Dali::Signal; - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_Empty(void *arg1) { - bool result = false; - GUARD_ON_NULL_RET0(arg1); - try_catch(([&]() { - auto object = (GesturePairSignal*)arg1; - result = object->Empty(); - })); - return result; -} - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_GetConnectionCount(void *arg1) { - std::size_t result = 0; - GUARD_ON_NULL_RET0(arg1); - try_catch(([&]() { - auto object = (GesturePairSignal*)arg1; - result = object->GetConnectionCount(); - })); - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_Connect(void *arg1, void *arg2) { - GUARD_ON_NULL_RET(arg1); - GUARD_ON_NULL_RET(arg2); - try_catch(([&]() { - auto object = (GesturePairSignal*)arg1; - auto func = (GesturePairFunc)arg2; - object->Connect( func ); - })); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_Disconnect(void *arg1, void *arg2) { - GUARD_ON_NULL_RET(arg1); - GUARD_ON_NULL_RET(arg2); - try_catch(([&]() { - auto object = (GesturePairSignal*)arg1; - auto func = (GesturePairFunc)arg2; - object->Disconnect(func); - })); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_Emit(void *arg1, void *arg2) { - GUARD_ON_NULL_RET(arg1); - GUARD_ON_NULL_RET(arg2); - try_catch(([&]() { - auto object = (GesturePairSignal*)arg1; - auto gesturePair = (GesturePair*)arg2; - object->Emit(*gesturePair); - })); -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_new() { - try_catch(([&]() { - return new GesturePairSignal(); - })); - return nullptr; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_delete(void *arg1) { - GUARD_ON_NULL_RET(arg1); - try_catch(([&]() { - auto object = (GesturePairSignal*)arg1; - delete object; - })); -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_GetSizeOfGestureInfo(void) { - return sizeof(Dali::Accessibility::GestureInfo); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_GetResult(void *arg1) { - bool result = false; - GUARD_ON_NULL_RET0(arg1); - try_catch(([&]() { - auto gesturePair = (GesturePair*)arg1; - result = (bool)gesturePair->second; - })); - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Signal_GesturePairToVoid_SetResult(void *arg1, bool arg2) { - bool result = arg2; - GUARD_ON_NULL_RET(arg1); - try_catch(([&]() { - auto gesturePair = (GesturePair*)arg1; - gesturePair->second = result; - })); -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/slide-transition-wrap.cpp b/dali-csharp-binder/src/slide-transition-wrap.cpp deleted file mode 100755 index 30b997a8..00000000 --- a/dali-csharp-binder/src/slide-transition-wrap.cpp +++ /dev/null @@ -1,228 +0,0 @@ -/* - * Copyright (c) 2021 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_SlideTransition() - { - void *jresult; - Dali::Toolkit::SlideTransition *result = 0; - - { - try - { - result = (Dali::Toolkit::SlideTransition *)new Dali::Toolkit::SlideTransition(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SlideTransition_New(void *nuiControl, void *nuiDirection, void *nuiTimePeriod) - { - void *jresult; - Dali::Toolkit::Control *control = (Dali::Toolkit::Control *)nuiControl; - Dali::Vector2 *direction = (Dali::Vector2 *)nuiDirection; - Dali::TimePeriod *timePeriod = (Dali::TimePeriod *)nuiTimePeriod; - - Dali::Toolkit::SlideTransition result; - - if (!control) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0); - return 0; - } - if (!direction) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return 0; - } - { - try - { - result = Dali::Toolkit::SlideTransition::New(*control, *direction, *timePeriod); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::SlideTransition((const Dali::Toolkit::SlideTransition &)result); - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlideTransition(void *nuiSlideTransition) - { - Dali::Toolkit::SlideTransition *slide = (Dali::Toolkit::SlideTransition *)0; - - slide = (Dali::Toolkit::SlideTransition *)nuiSlideTransition; - - if (!slide) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0); - return; - } - { - try - { - delete slide; - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_SlideTransition_Set(void *nuiSlideTransition) - { - Dali::Toolkit::SlideTransition *newSlideTransition = 0; - Dali::Toolkit::SlideTransition *slide = (Dali::Toolkit::SlideTransition *)nuiSlideTransition; - - if (!slide) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::SlideTransition const & type is null", 0); - return 0; - } - { - try - { - newSlideTransition = (Dali::Toolkit::SlideTransition *)new Dali::Toolkit::SlideTransition((Dali::Toolkit::SlideTransition const &)*slide); - } - CALL_CATCH_EXCEPTION(0); - } - void *result; - result = (void *)newSlideTransition; - return result; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SlideTransition_Assign(void *nuiDestination, void *nuiSource) - { - void *jresult; - Dali::Toolkit::SlideTransition *destination = (Dali::Toolkit::SlideTransition *)0; - Dali::Toolkit::SlideTransition *source = 0; - Dali::Toolkit::SlideTransition *result = 0; - - destination = (Dali::Toolkit::SlideTransition *)nuiDestination; - source = (Dali::Toolkit::SlideTransition *)nuiSource; - - if (!destination) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::SlideTransition const & type is null", 0); - return 0; - } - if (!source) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::SlideTransition const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Toolkit::SlideTransition *)&(destination)->operator=((Dali::Toolkit::SlideTransition const &)*source); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlideTransition_SetDirection(void *nuiSlideTransition, void *nuiDirection) - { - Dali::Toolkit::SlideTransition *slide = (Dali::Toolkit::SlideTransition *)nuiSlideTransition; - Dali::Vector2 *direction = (Dali::Vector2 *)nuiDirection; - - if (!slide) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::SlideTransition const & type is null", 0); - return; - } - if (!direction) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0); - return; - } - { - try - { - (slide)->SetDirection((Dali::Vector2 const &)*direction); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SlideTransition_GetDirection(void *nuiSlideTransition) - { - void *jresult; - Dali::Toolkit::SlideTransition *slide = (Dali::Toolkit::SlideTransition *)nuiSlideTransition; - Dali::Vector2 result; - - if (!slide) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::SlideTransition const & type is null", 0); - return 0; - } - { - try - { - result = (slide)->GetDirection(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector2((const Dali::Vector2 &)result); - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SlideTransitionDirectionTop_get() - { - Dali::Vector2 *result = (Dali::Vector2 *)&Dali::Toolkit::SlideTransitionDirection::TOP; - - return (void *)result; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SlideTransitionDirectionBottom_get() - { - Dali::Vector2 *result = (Dali::Vector2 *)&Dali::Toolkit::SlideTransitionDirection::BOTTOM; - - return (void *)result; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SlideTransitionDirectionRight_get() - { - Dali::Vector2 *result = (Dali::Vector2 *)&Dali::Toolkit::SlideTransitionDirection::RIGHT; - - return (void *)result; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SlideTransitionDirectionLeft_get() - { - Dali::Vector2 *result = (Dali::Vector2 *)&Dali::Toolkit::SlideTransitionDirection::LEFT; - - return (void *)result; - } - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/slim-custom-view-impl.cpp b/dali-csharp-binder/src/slim-custom-view-impl.cpp deleted file mode 100644 index a2ecdce2..00000000 --- a/dali-csharp-binder/src/slim-custom-view-impl.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* - * Copyright (c) 2023 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. - * - */ - -// CLASS HEADER -#include "slim-custom-view-impl.h" - -// EXTERNAL INCLUDES -#include -#include -#include - -// INTERNAL INCLUDES -#include "nui-view-accessible.h" - -SlimCustomViewImpl::SlimCustomViewImpl(ControlBehaviour behaviourFlags) : Control(behaviourFlags) -{ -} - -Dali::Toolkit::Control SlimCustomViewImpl::New(ControlBehaviour additionalBehaviour) -{ - // Create the implementation, temporarily owned on stack - Dali::IntrusivePtr controlImpl = new SlimCustomViewImpl(Control::ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT | additionalBehaviour)); - - // Pass ownership to handle - Dali::Toolkit::Control handle(*controlImpl); - - // Second-phase init of the implementation - // This can only be done after the CustomActor connection has been made... - controlImpl->Initialize(); - - // Impersonate Control by adopting its TypeInfo. Without this, many things don't work. - Dali::TypeInfo typeInfo = Dali::TypeRegistry::Get().GetTypeInfo(typeid(Control)); - if(typeInfo) - { - Dali::DevelHandle::SetTypeInfo(handle, typeInfo); - } - - return handle; -} - -Dali::Toolkit::DevelControl::ControlAccessible* SlimCustomViewImpl::CreateAccessibleObject() -{ - return new NUIViewAccessible(Self()); -} diff --git a/dali-csharp-binder/src/slim-custom-view-impl.h b/dali-csharp-binder/src/slim-custom-view-impl.h deleted file mode 100644 index a2cb8e6a..00000000 --- a/dali-csharp-binder/src/slim-custom-view-impl.h +++ /dev/null @@ -1,45 +0,0 @@ -#ifndef CSHARP_SLIM_CUSTOM_VIEW_IMPL_H -#define CSHARP_SLIM_CUSTOM_VIEW_IMPL_H - -/* - * Copyright (c) 2023 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -// SlimCustomViewImpl behaves almost identically to Toolkit::Internal::Control, -// but is associated with a NUIViewAccessible, therefore opening the possibility -// of providing Accessibility support in C#. -class SlimCustomViewImpl : public Dali::Toolkit::Internal::Control -{ - using Dali::Toolkit::Internal::Control::ControlBehaviour; - - SlimCustomViewImpl(ControlBehaviour behaviourFlags); - -public: - static Dali::Toolkit::Control New(ControlBehaviour additionalBehaviour); - -protected: - Dali::Toolkit::DevelControl::ControlAccessible* CreateAccessibleObject() override; -}; - -#endif // CSHARP_SLIM_CUSTOM_VIEW_IMPL_H diff --git a/dali-csharp-binder/src/stdafx.h b/dali-csharp-binder/src/stdafx.h deleted file mode 100644 index d42a852c..00000000 --- a/dali-csharp-binder/src/stdafx.h +++ /dev/null @@ -1,30 +0,0 @@ -/* - * 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. - * - */ - -// stdafx.h : include file for standard system include files, -// or project specific include files that are used frequently, but -// are changed infrequently -// - -#pragma once - -#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers - -// Windows Header Files: -#include - -// TODO: reference additional headers your program requires here diff --git a/dali-csharp-binder/src/style-manager-wrap.cpp b/dali-csharp-binder/src/style-manager-wrap.cpp deleted file mode 100644 index b7fd20a1..00000000 --- a/dali-csharp-binder/src/style-manager-wrap.cpp +++ /dev/null @@ -1,69 +0,0 @@ -/* - * Copyright (c) 2021 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -/* Callback for returning strings to C# without leaking memory */ -typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char*); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetBrokenImageUrl(void * nuiStyleManager, unsigned int brokenType, char * nuiUrl) { - Dali::Toolkit::StyleManager *styleManager = (Dali::Toolkit::StyleManager *) 0 ; - std::string *url = 0 ; - - if(!nuiUrl) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return; - } - - std::string url_str(nuiUrl); - url = &url_str; - styleManager = (Dali::Toolkit::StyleManager *)nuiStyleManager; - { - try { - Dali::Toolkit::DevelStyleManager::SetBrokenImageUrl(*styleManager,Dali::Toolkit::DevelStyleManager::BrokenImageType(brokenType),(std::string const &)*url); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StyleManager_GetBrokenImageUrl(void * nuiStyleManager, unsigned int brokenType) { - char * jresult ; - Dali::Toolkit::StyleManager *styleManager = (Dali::Toolkit::StyleManager *) 0 ; - std::string result; - - styleManager = (Dali::Toolkit::StyleManager *)nuiStyleManager; - { - try { - result = Dali::Toolkit::DevelStyleManager::GetBrokenImageUrl(*styleManager,Dali::Toolkit::DevelStyleManager::BrokenImageType(brokenType)); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback((&result)->c_str()); - return jresult; -} - -#ifdef __cplusplus -} -#endif \ No newline at end of file diff --git a/dali-csharp-binder/src/text-character-sequence-wrap.cpp b/dali-csharp-binder/src/text-character-sequence-wrap.cpp deleted file mode 100644 index 0f19115a..00000000 --- a/dali-csharp-binder/src/text-character-sequence-wrap.cpp +++ /dev/null @@ -1,127 +0,0 @@ -/* - * Copyright (c) 2022 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -/* Callback for returning strings to C# without leaking memory */ -typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -#ifdef __cplusplus -extern "C" { -#endif - -using namespace Dali::Toolkit::Text; - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_delete_CharacterSequence(void *refCharacterSequence) { - CharacterSequence *characterSequencePtr = (CharacterSequence *)0; - characterSequencePtr = (CharacterSequence *)refCharacterSequence; - - { - try { - delete characterSequencePtr; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL -CSharp_Dali_CharacterSequence_GetCharacters(void *refCharacterSequence) { - - CharacterSequence *characterSequencePtr; - void *result = nullptr; - - characterSequencePtr = (CharacterSequence *)refCharacterSequence; - if (!characterSequencePtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null CharacterSequence", 0); - return 0; - } - - { - try { - result = new Dali::Vector( - (const Dali::Vector &)(characterSequencePtr - ->GetCharacters())); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT unsigned int SWIGSTDCALL -CSharp_Dali_CharacterSequence_GetNumberOfCharacters( - void *refCharacterSequence) { - - CharacterSequence *characterSequencePtr; - unsigned int result = 0; - - characterSequencePtr = (CharacterSequence *)refCharacterSequence; - if (!characterSequencePtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null CharacterSequence", 0); - return 0; - } - - { - try { - result = characterSequencePtr->GetNumberOfCharacters(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT char *SWIGSTDCALL -CSharp_Dali_CharacterSequence_ToString(void *refCharacterSequence) { - - CharacterSequence *characterSequencePtr; - std::string result; - - characterSequencePtr = (CharacterSequence *)refCharacterSequence; - if (!characterSequencePtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null CharacterSequence", 0); - return 0; - } - - { - try { - result = characterSequencePtr->ToString(); - } - CALL_CATCH_EXCEPTION(0); - } - - char *csResult = SWIG_csharp_string_callback(result.c_str()); - return csResult; -} - -#ifdef __cplusplus -} -#endif \ No newline at end of file diff --git a/dali-csharp-binder/src/text-editor-wrap.cpp b/dali-csharp-binder/src/text-editor-wrap.cpp deleted file mode 100755 index e1299ba6..00000000 --- a/dali-csharp-binder/src/text-editor-wrap.cpp +++ /dev/null @@ -1,1480 +0,0 @@ -/* - * Copyright (c) 2020 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -/* Callback for returning strings to C# without leaking memory */ -typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){ -return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){ - self->Emit( arg ); -} - -SWIGINTERN bool Dali_Signal_void_TextEditor_Scroll_Type__Empty(Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_void_TextEditor_Scroll_Type__GetConnectionCount(Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > const *self){ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_void_TextEditor_Scroll_Type__Connect(Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *self,void (*func)(Dali::Toolkit::TextEditor,Dali::Toolkit::TextEditor::Scroll::Type)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_void_TextEditor_Scroll_Type__Disconnect(Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *self,void (*func)(Dali::Toolkit::TextEditor,Dali::Toolkit::TextEditor::Scroll::Type)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_void_TextEditor_Scroll_Type__Emit(Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *self,Dali::Toolkit::TextEditor arg1,Dali::Toolkit::TextEditor::Scroll::Type arg2){ - self->Emit( arg1, arg2 ); -} - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - -/*TextEditor Property binding*/ -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::RENDERING_BACKEND; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::TEXT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_VERTICAL_ALIGNMENT_get() { - - return (int)Dali::Toolkit::DevelTextEditor::Property::VERTICAL_ALIGNMENT; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RELATIVE_LINE_SIZE_get() { - - return (int)Dali::Toolkit::DevelTextEditor::Property::RELATIVE_LINE_SIZE; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::SHADOW; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_SMOOTH_SCROLL_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::SMOOTH_SCROLL; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_SMOOTH_SCROLL_DURATION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::SMOOTH_SCROLL_DURATION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_ENABLE_SCROLL_BAR_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_SCROLL_BAR; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_SCROLL_BAR_SHOW_DURATION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_BAR_SHOW_DURATION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_SCROLL_BAR_FADE_DURATION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_BAR_FADE_DURATION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_PIXEL_SIZE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::PIXEL_SIZE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_LINE_COUNT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::LINE_COUNT; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_PLACEHOLDER_TEXT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::PLACEHOLDER_TEXT; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_PLACEHOLDER_TEXT_COLOR_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::PLACEHOLDER_TEXT_COLOR; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_ENABLE_SELECTION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_SELECTION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_PLACEHOLDER_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextEditor::Property::PLACEHOLDER; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTED_TEXT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::SELECTED_TEXT; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTED_TEXT_START_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::SELECTED_TEXT_START; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTED_TEXT_END_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::SELECTED_TEXT_END; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_SCROLL_POSITION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::HORIZONTAL_SCROLL_POSITION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_VERTICAL_SCROLL_POSITION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::VERTICAL_SCROLL_POSITION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_POSITION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::PRIMARY_CURSOR_POSITION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_COLOR_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::GRAB_HANDLE_COLOR; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FILTER_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::INPUT_FILTER; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_POPUP_STYLE_get() -{ - return (int)Dali::Toolkit::DevelTextEditor::Property::SELECTION_POPUP_STYLE; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditor_ScrollBy(void * jarg1, void * jarg2) { - Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0; - Dali::Vector2 *arg2 = 0 ; - - arg1 = (Dali::Toolkit::TextEditor *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 type is null", 0); - return ; - } - - { - try { - Dali::Toolkit::DevelTextEditor::ScrollBy( *arg1 , *arg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_EDITING_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::ENABLE_EDITING; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_SIZE_SCALE_get() -{ - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::FONT_SIZE_SCALE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_FONT_SIZE_SCALE_get() -{ - return (int)Dali::Toolkit::DevelTextEditor::Property::ENABLE_FONT_SIZE_SCALE; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_GRAB_HANDLE_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::ENABLE_GRAB_HANDLE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_GRAB_HANDLE_POPUP_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::ENABLE_GRAB_HANDLE_POPUP; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_METHOD_SETTINGS_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::INPUT_METHOD_SETTINGS; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() { - void * jresult ; - Dali::Toolkit::TextEditor::Property *result = 0 ; - - { - try { - result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) { - Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ; - - arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() { - void * jresult ; - Dali::Toolkit::TextEditor::InputStyle *result = 0 ; - - { - try { - result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) { - Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ; - - arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() { - void * jresult ; - Dali::Toolkit::TextEditor result; - - { - try { - result = Dali::Toolkit::TextEditor::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New_With_Style(bool hasStyle) { - void * jresult ; - Dali::Toolkit::TextEditor result; - - { - try { - if (hasStyle) { - result = Dali::Toolkit::TextEditor::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS); - } else { - result = Dali::Toolkit::TextEditor::New(); - } - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() { - void * jresult ; - Dali::Toolkit::TextEditor *result = 0 ; - - { - try { - result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::TextEditor *arg1 = 0 ; - Dali::Toolkit::TextEditor *result = 0 ; - - arg1 = (Dali::Toolkit::TextEditor *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ; - Dali::Toolkit::TextEditor *arg2 = 0 ; - Dali::Toolkit::TextEditor *result = 0 ; - - arg1 = (Dali::Toolkit::TextEditor *)jarg1; - arg2 = (Dali::Toolkit::TextEditor *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) { - Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ; - - arg1 = (Dali::Toolkit::TextEditor *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::TextEditor 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::TextEditor::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ; - Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::TextEditor *)jarg1; - { - try { - result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ; - Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::TextEditor *)jarg1; - { - try { - result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_AnchorClickedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ; - Dali::Toolkit::DevelTextEditor::AnchorClickedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::TextEditor *)jarg1; - { - try { - result = (Dali::Toolkit::DevelTextEditor::AnchorClickedSignalType *)&Dali::Toolkit::DevelTextEditor::AnchorClickedSignal(*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputFilteredSignal(void * pTextEditor) { - void * jresult ; - Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0 ; - Dali::Toolkit::DevelTextEditor::InputFilteredSignalType *result = 0 ; - - textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; - { - try { - result = (Dali::Toolkit::DevelTextEditor::InputFilteredSignalType *)&Dali::Toolkit::DevelTextEditor::InputFilteredSignal(*textEditor); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditor_SelectWholeText(void * jarg1) { - Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0; - - arg1 = (Dali::Toolkit::TextEditor *)jarg1; - { - try { - Dali::Toolkit::DevelTextEditor::SelectWholeText( *arg1 ); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditor_SelectText(void * pTextEditor, unsigned int start, unsigned int end) { - Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0; - - textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; - { - try { - Dali::Toolkit::DevelTextEditor::SelectText( *textEditor, start, end ); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditor_SelectNone(void * jarg1) { - Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0; - - arg1 = (Dali::Toolkit::TextEditor *)jarg1; - { - try { - Dali::Toolkit::DevelTextEditor::SelectNone( *arg1 ); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_GetTextSize(void * pTextEditor, unsigned int start, unsigned int end) -{ - Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0; - void* sizeList; - - textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; - { - try { - sizeList = new Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > - ((const Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > &)(Dali::Toolkit::DevelTextEditor::GetTextSize( *textEditor, start, end ))); - } - CALL_CATCH_EXCEPTION(0); - } - - return sizeList; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_GetTextPosition(void * pTextEditor, unsigned int start, unsigned int end) -{ - Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0; - void* sizeList; - - textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; - { - try { - sizeList = new Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > - ((const Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > &)(Dali::Toolkit::DevelTextEditor::GetTextPosition( *textEditor, start, end ))); - } - CALL_CATCH_EXCEPTION(0); - } - - return sizeList; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_TextGeometry_TextEditor_GetTextBoundingRectangle(void * pTextEditor, uint32_t startIndex, uint32_t endIndex) -{ - Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0; - void* boundingRect; - - textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; - { - try { - boundingRect = new Dali::Rect<> - ((const Dali::Rect<> &)(Dali::Toolkit::DevelTextEditor::GetTextBoundingRectangle( *textEditor, startIndex, endIndex))); - } - CALL_CATCH_EXCEPTION(0); - } - - return boundingRect; -} - -SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_TextEditor_CopyText(void *pTextEditor) -{ - char *csCopiedText; - Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *)0; - std::string copiedText; - - textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; - { - try { - copiedText = Dali::Toolkit::DevelTextEditor::CopyText(*textEditor); - } - CALL_CATCH_EXCEPTION(0); - } - csCopiedText = SWIG_csharp_string_callback((&copiedText)->c_str()); - return csCopiedText; -} - -SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_TextEditor_CutText(void *pTextEditor) -{ - char *csCutText; - Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *)0; - std::string cutText; - - textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; - { - try { - cutText = Dali::Toolkit::DevelTextEditor::CutText(*textEditor); - } - CALL_CATCH_EXCEPTION(0); - } - csCutText = SWIG_csharp_string_callback((&cutText)->c_str()); - return csCutText; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditor_PasteText(void *pTextEditor) -{ - Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *)0; - - textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; - { - try { - Dali::Toolkit::DevelTextEditor::PasteText(*textEditor); - } - CALL_CATCH_EXCEPTION(); - } -} - -/*TextEditorSignal*/ -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ; - void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ; - void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ; - Dali::Toolkit::TextEditor arg2 ; - Dali::Toolkit::TextEditor *argp2 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1; - argp2 = (Dali::Toolkit::TextEditor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0); - return ; - } - arg2 = *argp2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() { - void * jresult ; - Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) { - Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - -/*ScrollStateChangedSignal*/ -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_ScrollStateChangedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::TextEditor *arg1 = 0 ; - Dali::Toolkit::TextEditor::ScrollStateChangedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::TextEditor *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::TextEditor::ScrollStateChangedSignalType *) &arg1->ScrollStateChangedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollStateChangedSignal_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *)jarg1; - { - try { - result = (bool)Dali_Signal_void_TextEditor_Scroll_Type__Empty((Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollStateChangedSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *)jarg1; - { - try { - result = Dali_Signal_void_TextEditor_Scroll_Type__GetConnectionCount((Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollStateChangedSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *) 0 ; - void (*arg2)(Dali::Toolkit::TextEditor,Dali::Toolkit::TextEditor::Scroll::Type) = (void (*)(Dali::Toolkit::TextEditor,Dali::Toolkit::TextEditor::Scroll::Type)) 0 ; - - arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::TextEditor,Dali::Toolkit::TextEditor::Scroll::Type))jarg2; - { - try { - Dali_Signal_void_TextEditor_Scroll_Type__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollStateChangedSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *) 0 ; - void (*arg2)(Dali::Toolkit::TextEditor,Dali::Toolkit::TextEditor::Scroll::Type) = (void (*)(Dali::Toolkit::TextEditor,Dali::Toolkit::TextEditor::Scroll::Type)) 0 ; - - arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::TextEditor,Dali::Toolkit::TextEditor::Scroll::Type))jarg2; - { - try { - Dali_Signal_void_TextEditor_Scroll_Type__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollStateChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) { - Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *) 0 ; - Dali::Toolkit::TextEditor arg2 ; - Dali::Toolkit::TextEditor::Scroll::Type arg3; - Dali::Toolkit::TextEditor *argp2 ; - - arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *)jarg1; - argp2 = (Dali::Toolkit::TextEditor *)jarg2; - arg3 = (Dali::Toolkit::TextEditor::Scroll::Type)jarg3; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0); - return ; - } - arg2 = *argp2; - { - try { - Dali_Signal_void_TextEditor_Scroll_Type__Emit(arg1,arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollStateChangedSignal() { - void * jresult ; - Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *result = 0 ; - - { - try { - result = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *)new Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollStateChangedSignal(void * jarg1) { - Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *) 0 ; - - arg1 = (Dali::Signal< void ( Dali::Toolkit::TextEditor, Dali::Toolkit::TextEditor::Scroll::Type ) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_ENABLE_SHIFT_SELECTION_get() -{ - return (int)Dali::Toolkit::DevelTextEditor::Property::ENABLE_SHIFT_SELECTION; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextEditor_Property_MATCH_SYSTEM_LANGUAGE_DIRECTION_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_MAX_LENGTH_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextEditor::Property::MAX_LENGTH; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_GetInputMethodContext(void * jarg1) { - void * jresult ; - Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ; - Dali::InputMethodContext result; - - arg1 = (Dali::Toolkit::TextEditor *)jarg1; - { - try { - result = Dali::Toolkit::DevelTextEditor::GetInputMethodContext(*arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::InputMethodContext((const Dali::InputMethodContext &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_CursorPositionChangedSignal(void * pTextEditor) { - void * jresult ; - Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0 ; - Dali::Toolkit::DevelTextEditor::CursorPositionChangedSignalType *result = 0 ; - - textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; - { - try { - result = (Dali::Toolkit::DevelTextEditor::CursorPositionChangedSignalType *)&Dali::Toolkit::DevelTextEditor::CursorPositionChangedSignal(*textEditor); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_MaxLengthReachedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ; - Dali::Toolkit::DevelTextEditor::MaxLengthReachedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::TextEditor *)jarg1; - { - try { - result = (Dali::Toolkit::DevelTextEditor::MaxLengthReachedSignalType *)&Dali::Toolkit::DevelTextEditor::MaxLengthReachedSignal(*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_SelectionClearedSignal(void * pTextEditor) { - void * jresult ; - Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0 ; - Dali::Toolkit::DevelTextEditor::SelectionClearedSignalType *result = 0 ; - - textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; - { - try { - result = (Dali::Toolkit::DevelTextEditor::SelectionClearedSignalType *)&Dali::Toolkit::DevelTextEditor::SelectionClearedSignal(*textEditor); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_SelectionStartedSignal(void * pTextEditor) { - void * jresult ; - Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0 ; - Dali::Toolkit::DevelTextEditor::SelectionStartedSignalType *result = 0 ; - - textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; - { - try { - result = (Dali::Toolkit::DevelTextEditor::SelectionStartedSignalType *)&Dali::Toolkit::DevelTextEditor::SelectionStartedSignal(*textEditor); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_SelectionChangedSignal(void * pTextEditor) { - void * jresult ; - Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0 ; - Dali::Toolkit::DevelTextEditor::SelectionChangedSignalType *result = 0 ; - - textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; - { - try { - result = (Dali::Toolkit::DevelTextEditor::SelectionChangedSignalType *)&Dali::Toolkit::DevelTextEditor::SelectionChangedSignal(*textEditor); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/text-field-wrap.cpp b/dali-csharp-binder/src/text-field-wrap.cpp deleted file mode 100755 index 94544422..00000000 --- a/dali-csharp-binder/src/text-field-wrap.cpp +++ /dev/null @@ -1,1255 +0,0 @@ -/* - * Copyright (c) 2020 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -/* Callback for returning strings to C# without leaking memory */ -typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){ -return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){ - self->Emit( arg ); -} - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - -/*TextField property binding*/ -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextField::Property::RENDERING_BACKEND; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::TEXT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::UNDERLINE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::SHADOW; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::EMBOSS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::OUTLINE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_HIDDEN_INPUT_SETTINGS_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::HIDDEN_INPUT_SETTINGS; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_PIXEL_SIZE_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::PIXEL_SIZE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_ENABLE_SELECTION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::ENABLE_SELECTION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_ENABLE_GRAB_HANDLE_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelTextField::Property::ENABLE_GRAB_HANDLE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_ENABLE_GRAB_HANDLE_POPUP_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelTextField::Property::ENABLE_GRAB_HANDLE_POPUP; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_PLACEHOLDER_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_ELLIPSIS_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::TextField::Property::ELLIPSIS; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTED_TEXT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextField::Property::SELECTED_TEXT; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTED_TEXT_START_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextField::Property::SELECTED_TEXT_START; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTED_TEXT_END_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextField::Property::SELECTED_TEXT_END; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_EDITING_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextField::Property::ENABLE_EDITING; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_SIZE_SCALE_get() -{ - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelTextField::Property::FONT_SIZE_SCALE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_FONT_SIZE_SCALE_get() -{ - return (int)Dali::Toolkit::DevelTextField::Property::ENABLE_FONT_SIZE_SCALE; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_POSITION_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextField::Property::PRIMARY_CURSOR_POSITION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_COLOR_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextField::Property::GRAB_HANDLE_COLOR; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FILTER_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::DevelTextField::Property::INPUT_FILTER; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_POPUP_STYLE_get() -{ - return (int)Dali::Toolkit::DevelTextField::Property::SELECTION_POPUP_STYLE; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() { - void * jresult ; - Dali::Toolkit::TextField::Property *result = 0 ; - - { - try { - result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) { - Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ; - - arg1 = (Dali::Toolkit::TextField::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() { - void * jresult ; - Dali::Toolkit::TextField::InputStyle *result = 0 ; - - { - try { - result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) { - Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ; - - arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() { - void * jresult ; - Dali::Toolkit::TextField result; - - { - try { - result = Dali::Toolkit::TextField::New(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New_With_Style(bool hasStyle) { - void * jresult ; - Dali::Toolkit::TextField result; - - { - try { - if (hasStyle) { - result = Dali::Toolkit::TextField::New(Dali::Toolkit::Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS); - } else { - result = Dali::Toolkit::TextField::New(); - } - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() { - void * jresult ; - Dali::Toolkit::TextField *result = 0 ; - - { - try { - result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::TextField *arg1 = 0 ; - Dali::Toolkit::TextField *result = 0 ; - - arg1 = (Dali::Toolkit::TextField *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ; - Dali::Toolkit::TextField *arg2 = 0 ; - Dali::Toolkit::TextField *result = 0 ; - - arg1 = (Dali::Toolkit::TextField *)jarg1; - arg2 = (Dali::Toolkit::TextField *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) { - Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ; - - arg1 = (Dali::Toolkit::TextField *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::TextField 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::TextField::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ; - Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::TextField *)jarg1; - { - try { - result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_CursorPositionChangedSignal(void * pTextField) { - void * jresult ; - Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0 ; - Dali::Toolkit::DevelTextField::CursorPositionChangedSignalType *result = 0 ; - - textField = (Dali::Toolkit::TextField *)pTextField; - { - try { - result = (Dali::Toolkit::DevelTextField::CursorPositionChangedSignalType *)&Dali::Toolkit::DevelTextField::CursorPositionChangedSignal(*textField); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ; - Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::TextField *)jarg1; - { - try { - result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ; - Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::TextField *)jarg1; - { - try { - result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_AnchorClickedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ; - Dali::Toolkit::DevelTextField::AnchorClickedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::TextField *)jarg1; - { - try { - result = (Dali::Toolkit::DevelTextField::AnchorClickedSignalType *)&Dali::Toolkit::DevelTextField::AnchorClickedSignal(*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputFilteredSignal(void * pTextField) { - void * jresult ; - Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0 ; - Dali::Toolkit::DevelTextField::InputFilteredSignalType *result = 0 ; - - textField = (Dali::Toolkit::TextField *)pTextField; - { - try { - result = (Dali::Toolkit::DevelTextField::InputFilteredSignalType *)&Dali::Toolkit::DevelTextField::InputFilteredSignal(*textField); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextField_SelectWholeText(void * jarg1) { - Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0; - - arg1 = (Dali::Toolkit::TextField *)jarg1; - { - try { - Dali::Toolkit::DevelTextField::SelectWholeText( *arg1 ); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextField_SelectText(void * pTextField, unsigned int start, unsigned int end) { - Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0; - - textField = (Dali::Toolkit::TextField *)pTextField; - { - try { - Dali::Toolkit::DevelTextField::SelectText( *textField, start, end ); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextField_SelectNone(void * jarg1) { - Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0; - - arg1 = (Dali::Toolkit::TextField *)jarg1; - { - try { - Dali::Toolkit::DevelTextField::SelectNone( *arg1 ); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_GetTextSize(void * pTextField, unsigned int start, unsigned int end) -{ - Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0; - void* sizeList; - - textField = (Dali::Toolkit::TextField *)pTextField; - { - try { - sizeList = new Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > - ((const Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > &)(Dali::Toolkit::DevelTextField::GetTextSize( *textField, start, end ))); - } - CALL_CATCH_EXCEPTION(0); - } - - return sizeList; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_GetTextPosition(void * pTextField, unsigned int start, unsigned int end) -{ - Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0; - void* sizeList; - - textField = (Dali::Toolkit::TextField *)pTextField; - { - try { - sizeList = new Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > - ((const Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > &)(Dali::Toolkit::DevelTextField::GetTextPosition( *textField, start, end ))); - } - CALL_CATCH_EXCEPTION(0); - } - - return sizeList; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_TextGeometry_TextField_GetTextBoundingRectangle(void * pTextField, uint32_t startIndex, uint32_t endIndex) -{ - Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0; - void* boundingRect; - - textField = (Dali::Toolkit::TextField *)pTextField; - { - try { - boundingRect = new Dali::Rect<> - ((const Dali::Rect<> &)(Dali::Toolkit::DevelTextField::GetTextBoundingRectangle( *textField, startIndex, endIndex))); - } - CALL_CATCH_EXCEPTION(0); - } - - return boundingRect; -} - -SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_TextField_CopyText(void *pTextField) -{ - char *csCopiedText; - Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *)0; - std::string copiedText; - - textField = (Dali::Toolkit::TextField *)pTextField; - { - try { - copiedText = Dali::Toolkit::DevelTextField::CopyText(*textField); - } - CALL_CATCH_EXCEPTION(0); - } - csCopiedText = SWIG_csharp_string_callback((&copiedText)->c_str()); - return csCopiedText; -} - -SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_TextField_CutText(void *pTextField) -{ - char *csCutText; - Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *)0; - std::string cutText; - - textField = (Dali::Toolkit::TextField *)pTextField; - { - try { - cutText = Dali::Toolkit::DevelTextField::CutText(*textField); - } - CALL_CATCH_EXCEPTION(0); - } - csCutText = SWIG_csharp_string_callback((&cutText)->c_str()); - return csCutText; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextField_PasteText(void *pTextField) -{ - Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *)0; - - textField = (Dali::Toolkit::TextField *)pTextField; - { - try { - Dali::Toolkit::DevelTextField::PasteText(*textField); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ; - void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::TextField))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ; - void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::TextField))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ; - Dali::Toolkit::TextField arg2 ; - Dali::Toolkit::TextField *argp2 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1; - argp2 = (Dali::Toolkit::TextField *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0); - return ; - } - arg2 = *argp2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() { - void * jresult ; - Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) { - Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_ENABLE_SHIFT_SELECTION_get() -{ - return (int)Dali::Toolkit::DevelTextField::Property::ENABLE_SHIFT_SELECTION; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextField_Property_MATCH_SYSTEM_LANGUAGE_DIRECTION_get() { - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelTextField::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_GetInputMethodContext(void * jarg1) { - void * jresult ; - Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ; - Dali::InputMethodContext result; - - arg1 = (Dali::Toolkit::TextField *)jarg1; - { - try { - result = Dali::Toolkit::DevelTextField::GetInputMethodContext(*arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::InputMethodContext((const Dali::InputMethodContext &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_SelectionClearedSignal(void * pTextField) { - void * jresult ; - Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0 ; - Dali::Toolkit::DevelTextField::SelectionClearedSignalType *result = 0 ; - - textField = (Dali::Toolkit::TextField *)pTextField; - { - try { - result = (Dali::Toolkit::DevelTextField::SelectionClearedSignalType *)&Dali::Toolkit::DevelTextField::SelectionClearedSignal(*textField); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_SelectionStartedSignal(void * pTextField) { - void * jresult ; - Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0 ; - Dali::Toolkit::DevelTextField::SelectionStartedSignalType *result = 0 ; - - textField = (Dali::Toolkit::TextField *)pTextField; - { - try { - result = (Dali::Toolkit::DevelTextField::SelectionStartedSignalType *)&Dali::Toolkit::DevelTextField::SelectionStartedSignal(*textField); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_SelectionChangedSignal(void * pTextField) { - void * jresult ; - Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0 ; - Dali::Toolkit::DevelTextField::SelectionChangedSignalType *result = 0 ; - - textField = (Dali::Toolkit::TextField *)pTextField; - { - try { - result = (Dali::Toolkit::DevelTextField::SelectionChangedSignalType *)&Dali::Toolkit::DevelTextField::SelectionChangedSignal(*textField); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/text-geometry-wrap.cpp b/dali-csharp-binder/src/text-geometry-wrap.cpp deleted file mode 100644 index 3ebbe27e..00000000 --- a/dali-csharp-binder/src/text-geometry-wrap.cpp +++ /dev/null @@ -1,187 +0,0 @@ -/* - * Copyright (c) 2021 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include -#include -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void * SWIGSTDCALL CSharp_TextGeometry_TextLabel_GetLineBoundingRectangle(void * pTextLabel, uint32_t lineIndex) -{ - Dali::Toolkit::TextLabel *textLabel = (Dali::Toolkit::TextLabel *) 0; - void* resultRect; - - textLabel = (Dali::Toolkit::TextLabel *)pTextLabel; - { - try { - resultRect = new Dali::Rect - ((const Dali::Rect &)(Dali::Toolkit::Text::TextGeometry::GetLineBoundingRectangle( *textLabel, lineIndex))); - } - CALL_CATCH_EXCEPTION(0); - } - - return resultRect; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_TextGeometry_TextField_GetLineBoundingRectangle(void * pTextField, uint32_t lineIndex) -{ - Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0; - void* resultRect; - - textField = (Dali::Toolkit::TextField *)pTextField; - { - try { - resultRect = new Dali::Rect - ((const Dali::Rect &)(Dali::Toolkit::Text::TextGeometry::GetLineBoundingRectangle( *textField, lineIndex))); - } - CALL_CATCH_EXCEPTION(0); - } - - return resultRect; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_TextGeometry_TextEditor_GetLineBoundingRectangle(void * pTextEditor, uint32_t lineIndex) -{ - Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0; - void* resultRect; - - textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; - { - try { - resultRect = new Dali::Rect - ((const Dali::Rect &)(Dali::Toolkit::Text::TextGeometry::GetLineBoundingRectangle( *textEditor, lineIndex))); - } - CALL_CATCH_EXCEPTION(0); - } - - return resultRect; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_TextGeometry_TextLabel_GetCharacterBoundingRectangle(void * pTextLabel, uint32_t charIndex) -{ - Dali::Toolkit::TextLabel *textLabel = (Dali::Toolkit::TextLabel *) 0; - void* resultRect; - - textLabel = (Dali::Toolkit::TextLabel *)pTextLabel; - { - try { - resultRect = new Dali::Rect<> - ((const Dali::Rect<> &)(Dali::Toolkit::Text::TextGeometry::GetCharacterBoundingRectangle( *textLabel, charIndex))); - } - CALL_CATCH_EXCEPTION(0); - } - - return resultRect; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_TextGeometry_TextField_GetCharacterBoundingRectangle(void * pTextField, uint32_t charIndex) -{ - Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0; - void* resultRect; - - textField = (Dali::Toolkit::TextField *)pTextField; - { - try { - resultRect = new Dali::Rect<> - ((const Dali::Rect<> &)(Dali::Toolkit::Text::TextGeometry::GetCharacterBoundingRectangle( *textField, charIndex))); - } - CALL_CATCH_EXCEPTION(0); - } - - return resultRect; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_TextGeometry_TextEditor_GetCharacterBoundingRectangle(void * pTextEditor, uint32_t charIndex) -{ - Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0; - void* resultRect; - - textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; - { - try { - resultRect = new Dali::Rect<> - ((const Dali::Rect<> &)(Dali::Toolkit::Text::TextGeometry::GetCharacterBoundingRectangle( *textEditor, charIndex))); - } - CALL_CATCH_EXCEPTION(0); - } - - return resultRect; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextGeometry_TextLabel_GetCharacterIndexAtPosition(void * pTextLabel, float visualX, float visualY) -{ - Dali::Toolkit::TextLabel *textLabel = (Dali::Toolkit::TextLabel *) 0; - int charIndex; - - textLabel = (Dali::Toolkit::TextLabel *)pTextLabel; - { - try { - charIndex = (int)(Dali::Toolkit::Text::TextGeometry::GetCharacterIndexAtPosition( *textLabel, visualX, visualY)); - } - CALL_CATCH_EXCEPTION(0); - } - - return charIndex; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextGeometry_TextField_GetCharacterIndexAtPosition(void * pTextField, float visualX, float visualY) -{ - Dali::Toolkit::TextField *textField = (Dali::Toolkit::TextField *) 0; - int charIndex; - - textField = (Dali::Toolkit::TextField *)pTextField; - { - try { - charIndex = (int)(Dali::Toolkit::Text::TextGeometry::GetCharacterIndexAtPosition( *textField, visualX, visualY)); - } - CALL_CATCH_EXCEPTION(0); - } - - return charIndex; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_TextGeometry_TextEditor_GetCharacterIndexAtPosition(void * pTextEditor, float visualX, float visualY) -{ - Dali::Toolkit::TextEditor *textEditor = (Dali::Toolkit::TextEditor *) 0; - int charIndex; - - textEditor = (Dali::Toolkit::TextEditor *)pTextEditor; - { - try { - charIndex = (int)(Dali::Toolkit::Text::TextGeometry::GetCharacterIndexAtPosition( *textEditor, visualX, visualY)); - } - CALL_CATCH_EXCEPTION(0); - } - - return charIndex; -} - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/text-label-wrap.cpp b/dali-csharp-binder/src/text-label-wrap.cpp deleted file mode 100755 index d7346cc2..00000000 --- a/dali-csharp-binder/src/text-label-wrap.cpp +++ /dev/null @@ -1,274 +0,0 @@ -/* - * Copyright (c) 2021 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextLabel) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextLabel) > const *self){ -return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextLabel) > *self,void (*func)(Dali::Toolkit::TextLabel)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextLabel) > *self,void (*func)(Dali::Toolkit::TextLabel)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextLabel) > *self,Dali::Toolkit::TextLabel arg){ - self->Emit( arg ); -} - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT int SWIGSTDCALL CSharp_TextLabel_Property_TEXT_FIT_get() -{ - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelTextLabel::Property::TEXT_FIT; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_SIZE_SCALE_get() -{ - int jresult; - int result; - - result = (int)Dali::Toolkit::DevelTextLabel::Property::FONT_SIZE_SCALE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_FONT_SIZE_SCALE_get() -{ - return (int)Dali::Toolkit::DevelTextLabel::Property::ENABLE_FONT_SIZE_SCALE; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RELATIVE_LINE_SIZE_get() { - - return (int)Dali::Toolkit::DevelTextLabel::Property::RELATIVE_LINE_SIZE; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_GetTextSize(void * pTextLabel, unsigned int start, unsigned int end) -{ - Dali::Toolkit::TextLabel *textLabel = (Dali::Toolkit::TextLabel *) 0; - void* sizeList; - - textLabel = (Dali::Toolkit::TextLabel *)pTextLabel; - { - try { - sizeList = new Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > - ((const Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > &)(Dali::Toolkit::DevelTextLabel::GetTextSize( *textLabel, start, end ))); - } - CALL_CATCH_EXCEPTION(0); - } - - return sizeList; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_GetTextPosition(void * pTextLabel, unsigned int start, unsigned int end) -{ - Dali::Toolkit::TextLabel *textLabel = (Dali::Toolkit::TextLabel *) 0; - void* sizeList; - - textLabel = (Dali::Toolkit::TextLabel *)pTextLabel; - { - try { - sizeList = new Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > - ((const Dali::Vector< Dali::Vector2, Dali::TypeTraits< Dali::Vector2 >::IS_TRIVIAL_TYPE==true > &)(Dali::Toolkit::DevelTextLabel::GetTextPosition( *textLabel, start, end ))); - } - CALL_CATCH_EXCEPTION(0); - } - - return sizeList; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_TextGeometry_TextLabel_GetTextBoundingRectangle(void * pTextLabel, uint32_t startIndex, uint32_t endIndex) -{ - Dali::Toolkit::TextLabel *textLabel = (Dali::Toolkit::TextLabel *) 0; - void* boundingRect; - - textLabel = (Dali::Toolkit::TextLabel *)pTextLabel; - { - try { - boundingRect = new Dali::Rect<> - ((const Dali::Rect<> &)(Dali::Toolkit::DevelTextLabel::GetTextBoundingRectangle( *textLabel, startIndex, endIndex))); - } - CALL_CATCH_EXCEPTION(0); - } - - return boundingRect; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_AnchorClickedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ; - Dali::Toolkit::DevelTextLabel::AnchorClickedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::TextLabel *)jarg1; - { - try { - result = (Dali::Toolkit::DevelTextLabel::AnchorClickedSignalType *)&Dali::Toolkit::DevelTextLabel::AnchorClickedSignal(*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_TextFitChangedSignal(void * jarg1) { - void * jresult ; - Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ; - Dali::Toolkit::DevelTextLabel::TextFitChangedSignalType *result = 0 ; - - arg1 = (Dali::Toolkit::TextLabel *)jarg1; - { - try { - result = (Dali::Toolkit::DevelTextLabel::TextFitChangedSignalType *) &Dali::Toolkit::DevelTextLabel::TextFitChangedSignal(*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextLabelSignal_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void (Dali::Toolkit::TextLabel) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextLabel) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextLabelSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Toolkit::TextLabel) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextLabel) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextLabelSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::TextLabel) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *) 0 ; - void (*arg2)(Dali::Toolkit::TextLabel) = (void (*)(Dali::Toolkit::TextLabel)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::TextLabel))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextLabelSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::TextLabel) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *) 0 ; - void (*arg2)(Dali::Toolkit::TextLabel) = (void (*)(Dali::Toolkit::TextLabel)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *)jarg1; - arg2 = (void (*)(Dali::Toolkit::TextLabel))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextLabelSignal_Emit(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Toolkit::TextLabel) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *) 0 ; - Dali::Toolkit::TextLabel arg2 ; - Dali::Toolkit::TextLabel *argp2 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *)jarg1; - argp2 = (Dali::Toolkit::TextLabel *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextLabel", 0); - return ; - } - arg2 = *argp2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextLabel_SP__Sg__Emit(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabelSignal() { - void * jresult ; - Dali::Signal< void (Dali::Toolkit::TextLabel) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *)new Dali::Signal< void (Dali::Toolkit::TextLabel) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabelSignal(void * jarg1) { - Dali::Signal< void (Dali::Toolkit::TextLabel) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Toolkit::TextLabel) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/text-range-wrap.cpp b/dali-csharp-binder/src/text-range-wrap.cpp deleted file mode 100644 index c0ed8f0f..00000000 --- a/dali-csharp-binder/src/text-range-wrap.cpp +++ /dev/null @@ -1,136 +0,0 @@ -/* - * Copyright (c) 2022 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -/* Callback for returning strings to C# without leaking memory */ -typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -#ifdef __cplusplus -extern "C" { -#endif - -using namespace Dali::Toolkit::Text; - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Range(void *refRange) { - Range *rangePtr = (Range *)0; - rangePtr = (Range *)refRange; - - { - try { - delete rangePtr; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Range_New(unsigned int argStartIndex, - unsigned int argEndIndex) { - - Range *rangePtr = 0; - { - try { - rangePtr = (Range *)new Range(Range::New(argStartIndex, argEndIndex)); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void *)rangePtr; -} - -SWIGEXPORT unsigned int SWIGSTDCALL -CSharp_Dali_Range_GetStartIndex(void *refRange) { - - Range *rangePtr; - unsigned int result = false; - - rangePtr = (Range *)refRange; - if (!rangePtr) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, - "Attempt to dereference null Range", - 0); - return 0; - } - - { - try { - result = rangePtr->GetStartIndex(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT unsigned int SWIGSTDCALL -CSharp_Dali_Range_GetEndIndex(void *refRange) { - - Range *rangePtr; - unsigned int result = false; - - rangePtr = (Range *)refRange; - if (!rangePtr) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, - "Attempt to dereference null Range", - 0); - return 0; - } - - { - try { - result = rangePtr->GetEndIndex(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT unsigned int SWIGSTDCALL -CSharp_Dali_Range_GetNumberOfIndices(void *refRange) { - - Range *rangePtr; - unsigned int result = false; - - rangePtr = (Range *)refRange; - if (!rangePtr) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, - "Attempt to dereference null Range", - 0); - return 0; - } - - { - try { - result = rangePtr->GetNumberOfIndices(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -#ifdef __cplusplus -} -#endif \ No newline at end of file diff --git a/dali-csharp-binder/src/text-spannable-api-wrap.cpp b/dali-csharp-binder/src/text-spannable-api-wrap.cpp deleted file mode 100644 index 91d90f9f..00000000 --- a/dali-csharp-binder/src/text-spannable-api-wrap.cpp +++ /dev/null @@ -1,125 +0,0 @@ -/* - * Copyright (c) 2022 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -/* Callback for returning strings to C# without leaking memory */ -typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -#ifdef __cplusplus -extern "C" { -#endif - -using namespace Dali::Toolkit::Text; - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_TextLabel_SetSpannedText(void *refTextLabel, void *refSpanned) { - - Dali::Toolkit::TextLabel *textLabelPtr = (Dali::Toolkit::TextLabel *)0; - textLabelPtr = (Dali::Toolkit::TextLabel *)refTextLabel; - if (!textLabelPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null TextLabel", 0); - return; - } - - Spanned *spannedPtr = (Spanned *)0; - spannedPtr = (Spanned *)refSpanned; - if (!spannedPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, "Attempt to dereference null Spanned", - 0); - return; - } - - { - try { - SetSpannedText(*textLabelPtr, *spannedPtr); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_TextField_SetSpannedText(void *refTextField, void *refSpanned) { - - Dali::Toolkit::TextField *textFieldPtr = (Dali::Toolkit::TextField *)0; - textFieldPtr = (Dali::Toolkit::TextField *)refTextField; - if (!textFieldPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null TextField", 0); - return; - } - - Spanned *spannedPtr = (Spanned *)0; - spannedPtr = (Spanned *)refSpanned; - if (!spannedPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, "Attempt to dereference null Spanned", - 0); - return; - } - - { - try { - SetSpannedText(*textFieldPtr, *spannedPtr); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_TextEditor_SetSpannedText(void *refTextEditor, void *refSpanned) { - - Dali::Toolkit::TextEditor *textEditorPtr = (Dali::Toolkit::TextEditor *)0; - textEditorPtr = (Dali::Toolkit::TextEditor *)refTextEditor; - if (!textEditorPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null TextEditor", 0); - return; - } - - Spanned *spannedPtr = (Spanned *)0; - spannedPtr = (Spanned *)refSpanned; - if (!spannedPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, "Attempt to dereference null Spanned", - 0); - return; - } - - { - try { - SetSpannedText(*textEditorPtr, *spannedPtr); - } - CALL_CATCH_EXCEPTION(); - } -} - -#ifdef __cplusplus -} -#endif \ No newline at end of file diff --git a/dali-csharp-binder/src/text-spannable-string-wrap.cpp b/dali-csharp-binder/src/text-spannable-string-wrap.cpp deleted file mode 100644 index 6efb945c..00000000 --- a/dali-csharp-binder/src/text-spannable-string-wrap.cpp +++ /dev/null @@ -1,66 +0,0 @@ -/* - * Copyright (c) 2022 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -/* Callback for returning strings to C# without leaking memory */ -typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -#ifdef __cplusplus -extern "C" { -#endif - -using namespace Dali::Toolkit::Text; - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_delete_SpannableString(void *refSpannableString) { - SpannableString *spannablePtr = (SpannableString *)0; - spannablePtr = (SpannableString *)refSpannableString; - - { - try { - delete spannablePtr; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_SpannableString_New(char *refText) { - - std::string text = std::string(refText); - SpannableString *spannableStringPtr = 0; - { - try { - spannableStringPtr = - (SpannableString *)new SpannableString(SpannableString::New(text)); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void *)spannableStringPtr; -} - -#ifdef __cplusplus -} -#endif \ No newline at end of file diff --git a/dali-csharp-binder/src/text-spannable-wrap.cpp b/dali-csharp-binder/src/text-spannable-wrap.cpp deleted file mode 100644 index 3d585bd8..00000000 --- a/dali-csharp-binder/src/text-spannable-wrap.cpp +++ /dev/null @@ -1,126 +0,0 @@ -/* - * Copyright (c) 2022 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -/* Callback for returning strings to C# without leaking memory */ -typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -#ifdef __cplusplus -extern "C" { -#endif - -using namespace Dali::Toolkit::Text; - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Spannable(void *refSpannable) { - Spannable *spannablePtr = (Spannable *)0; - spannablePtr = (Spannable *)refSpannable; - - { - try { - delete spannablePtr; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Spannable_AttachSpan(void *refSpannable, - void *refSpan, - void *refRange) { - - bool result = false; - - BaseSpan *baseSpanPtr; - baseSpanPtr = (BaseSpan *)refSpan; - if (!baseSpanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null BaseSpan", 0); - return result; - } - - Range *rangePtr; - rangePtr = (Range *)refRange; - if (!rangePtr) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, - "Attempt to dereference null Range", - 0); - return result; - } - - Spannable *spannablePtr; - spannablePtr = (Spannable *)refSpannable; - if (!spannablePtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Spannable", 0); - return result; - } - - { - try { - result = spannablePtr->AttachSpan(*baseSpanPtr, *rangePtr); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Spannable_DetachSpan(void *refSpannable, - void *refSpan) { - - bool result = false; - - BaseSpan *baseSpanPtr; - baseSpanPtr = (BaseSpan *)refSpan; - if (!baseSpanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null BaseSpan", 0); - return result; - } - - Spannable *spannablePtr; - spannablePtr = (Spannable *)refSpannable; - if (!spannablePtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Spannable", 0); - return result; - } - - { - try { - result = spannablePtr->DetachSpan(*baseSpanPtr); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -#ifdef __cplusplus -} -#endif \ No newline at end of file diff --git a/dali-csharp-binder/src/text-spanned-wrap.cpp b/dali-csharp-binder/src/text-spanned-wrap.cpp deleted file mode 100644 index 1a9fa216..00000000 --- a/dali-csharp-binder/src/text-spanned-wrap.cpp +++ /dev/null @@ -1,266 +0,0 @@ -/* - * Copyright (c) 2022 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -/* Callback for returning strings to C# without leaking memory */ -typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -#ifdef __cplusplus -extern "C" { -#endif - -using namespace Dali::Toolkit::Text; - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Spanned(void *refSpanned) { - Spanned *spannedPtr = (Spanned *)0; - spannedPtr = (Spanned *)refSpanned; - - { - try { - delete spannedPtr; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Spanned_GetAllSpans(void *refSpanned) { - - Spanned *spannedPtr; - void *result = nullptr; - - spannedPtr = (Spanned *)refSpanned; - if (!spannedPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, "Attempt to dereference null Spanned", - 0); - return 0; - } - - { - try { - result = new std::vector( - (const std::vector &)(spannedPtr->GetAllSpans())); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Spanned_RetrieveAllSpansAndRanges( - void *refSpanned, void *refVectorSpans, void *refVectorRanges) { - - std::vector *spanVectorPtr = (std::vector *)0; - spanVectorPtr = (std::vector *)refVectorSpans; - if (!spanVectorPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null vector", 0); - return; - } - - std::vector *rangeVectorPtr = (std::vector *)0; - rangeVectorPtr = (std::vector *)refVectorRanges; - if (!rangeVectorPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null vector", 0); - return; - } - - Spanned *spannedPtr; - spannedPtr = (Spanned *)refSpanned; - if (!spannedPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, "Attempt to dereference null Spanned", - 0); - return; - } - - { - try { - spannedPtr->RetrieveAllSpansAndRanges(*spanVectorPtr, *rangeVectorPtr); - } - CALL_CATCH_EXCEPTION(); - } - - return; -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_std_vector_BaseSpan_Create() { - void *nuiResult; - std::vector *result = 0; - - { - try { - result = (std::vector *)new std::vector(); - } - CALL_CATCH_EXCEPTION(0); - } - - nuiResult = (void *)result; - return nuiResult; -} - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_std_vector_BaseSpan_Release(void *refVector) { - std::vector *spanPtr = (std::vector *)0; - - spanPtr = (std::vector *)refVector; - { - try { - delete spanPtr; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_std_vector_BaseSpan_ValueOfIndex( - void *refVector, unsigned long argIndex) { - void *nuiResult; - std::vector *spanPtr = (std::vector *)0; - std::vector::size_type itemSize; - std::vector::value_type *result = 0; - - spanPtr = (std::vector *)refVector; - itemSize = (std::vector::size_type)argIndex; - { - try { - result = - (std::vector::value_type *)&(spanPtr)->operator[](itemSize); - } - CALL_CATCH_EXCEPTION(0); - } - - nuiResult = (void *)result; - return nuiResult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_std_vector_BaseSpan_TypeOfIndex( - void *refVector, unsigned long argIndex) { - - Dali::Toolkit::Text::SpanType::Value result; - std::vector *item = (std::vector *)0; - std::vector::size_type itemSize; - std::vector::value_type *spanPtr = 0; - - item = (std::vector *)refVector; - itemSize = (std::vector::size_type)argIndex; - { - try { - spanPtr = - (std::vector::value_type *)&(item)->operator[](itemSize); - result = spanPtr->GetSpanType(); - } - CALL_CATCH_EXCEPTION(0); - } - - int nuiResult = (int)result; - return nuiResult; -} - -SWIGEXPORT int SWIGSTDCALL -CSharp_Dali_std_vector_BaseSpan_Size(void *refVector) { - std::vector *spanVectorPtr = (std::vector *)0; - int size; - - spanVectorPtr = (std::vector *)refVector; - { - try { - size = (spanVectorPtr)->size(); - } - CALL_CATCH_EXCEPTION(0); - } - - return size; -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_std_vector_Range_Create() { - void *nuiResult; - std::vector *result = 0; - - { - try { - result = (std::vector *)new std::vector(); - } - CALL_CATCH_EXCEPTION(0); - } - - nuiResult = (void *)result; - return nuiResult; -} - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_std_vector_Range_Release(void *refVector) { - std::vector *rangePtr = (std::vector *)0; - - rangePtr = (std::vector *)refVector; - { - try { - delete rangePtr; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_std_vector_Range_ValueOfIndex( - void *refVector, unsigned long argIndex) { - void *nuiResult; - std::vector *rangePtr = (std::vector *)0; - std::vector::size_type itemSize; - std::vector::value_type *result = 0; - - rangePtr = (std::vector *)refVector; - itemSize = (std::vector::size_type)argIndex; - { - try { - result = - (std::vector::value_type *)&(rangePtr)->operator[](itemSize); - } - CALL_CATCH_EXCEPTION(0); - } - - nuiResult = (void *)result; - return nuiResult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_std_vector_Range_Size(void *refVector) { - std::vector *rangePtr = (std::vector *)0; - int size; - - rangePtr = (std::vector *)refVector; - { - try { - size = (rangePtr)->size(); - } - CALL_CATCH_EXCEPTION(0); - } - - return size; -} - -#ifdef __cplusplus -} -#endif \ No newline at end of file diff --git a/dali-csharp-binder/src/text-spans-wrap.cpp b/dali-csharp-binder/src/text-spans-wrap.cpp deleted file mode 100644 index ebc26cc5..00000000 --- a/dali-csharp-binder/src/text-spans-wrap.cpp +++ /dev/null @@ -1,1254 +0,0 @@ -/* - * Copyright (c) 2022 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -/* Callback for returning strings to C# without leaking memory */ -typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -#ifdef __cplusplus -extern "C" { -#endif - -using namespace Dali::Toolkit::Text; - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseSpan(void *refBaseSpan) { - BaseSpan *baseSpanPtr = (BaseSpan *)0; - baseSpanPtr = (BaseSpan *)refBaseSpan; - - { - try { - delete baseSpanPtr; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BaseSpan_GetSpanType(void *refBaseSpan) { - - Dali::Toolkit::Text::SpanType::Value result; - - BaseSpan *spanPtr = (BaseSpan *)0; - spanPtr = (BaseSpan *)refBaseSpan; - if (!spanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null BaseSpan", 0); - return 0; - } - - { - try { - result = spanPtr->GetSpanType(); - } - CALL_CATCH_EXCEPTION(0); - } - - int nuiResult = (int)result; - return nuiResult; -} - -// ForegroundColorSpan - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_delete_ForegroundColorSpan(void *refSpan) { - ForegroundColorSpan *spanPtr = (ForegroundColorSpan *)0; - spanPtr = (ForegroundColorSpan *)refSpan; - - { - try { - delete spanPtr; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL -CSharp_Dali_ForegroundColorSpan_New(void *argColor) { - - Dali::Vector4 *colorPtr = 0; - colorPtr = (Dali::Vector4 *)argColor; - if (!colorPtr) { - - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::Vector4", 0); - return 0; - } - - ForegroundColorSpan *spanPtr = 0; - { - try { - spanPtr = (ForegroundColorSpan *)new ForegroundColorSpan( - ForegroundColorSpan::New((Dali::Vector4 const &)*colorPtr)); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void *)spanPtr; -} - -SWIGEXPORT void *SWIGSTDCALL -CSharp_Dali_ForegroundColorSpan_GetForegroundColor(void *refSpan) { - - ForegroundColorSpan *spanPtr; - Dali::Vector4 result; - - spanPtr = (ForegroundColorSpan *)refSpan; - if (!spanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null ForegroundColorSpan", 0); - return 0; - } - - { - try { - result = spanPtr->GetForegroundColor(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Vector4((const Dali::Vector4 &)result); -} - -SWIGEXPORT bool SWIGSTDCALL -CSharp_Dali_ForegroundColorSpan_IsForegroundColorDefined(void *refSpan) { - - ForegroundColorSpan *spanPtr; - bool result = false; - - spanPtr = (ForegroundColorSpan *)refSpan; - if (!spanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null ForegroundColorSpan", 0); - return 0; - } - - { - try { - result = spanPtr->IsForegroundColorDefined(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -// CharacterSpacing span - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_delete_CharacterSpacingSpan(void *refSpan) { - CharacterSpacingSpan *spanPtr = (CharacterSpacingSpan *)0; - spanPtr = (CharacterSpacingSpan *)refSpan; - { - try { - delete spanPtr; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL -CSharp_Dali_CharacterSpacingSpan_New(float argCharSpacing) { - float charSpacingPtr = (float)argCharSpacing; - - CharacterSpacingSpan *spanPtr = 0; - { - try { - spanPtr = (CharacterSpacingSpan *)new CharacterSpacingSpan( - CharacterSpacingSpan::New(charSpacingPtr)); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void *)spanPtr; -} - -SWIGEXPORT float SWIGSTDCALL -CSharp_Dali_CharacterSpacingSpan_GetCharacterSpacing(void *refSpan) { - - CharacterSpacingSpan *spanPtr; - float result = 0; - - spanPtr = (CharacterSpacingSpan *)refSpan; - if (!spanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null CharacterSpacingSpan", 0); - return 0; - } - - { - try { - result = spanPtr->GetCharacterSpacing(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL -CSharp_Dali_CharacterSpacingSpan_IsCharacterSpacingDefined(void *refSpan) { - CharacterSpacingSpan *spanPtr; - bool result = false; - - spanPtr = (CharacterSpacingSpan *)refSpan; - if (!spanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null CharacterSpacingSpan", 0); - return 0; - } - - { - try { - result = spanPtr->IsCharacterSpacingDefined(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -// BackgroundColorSpan - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_delete_BackgroundColorSpan(void *refSpan) { - BackgroundColorSpan *spanPtr = (BackgroundColorSpan *)0; - spanPtr = (BackgroundColorSpan *)refSpan; - - { - try { - delete spanPtr; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL -CSharp_Dali_BackgroundColorSpan_New(void *argColor) { - - Dali::Vector4 *colorPtr = 0; - colorPtr = (Dali::Vector4 *)argColor; - if (!colorPtr) { - - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::Vector4", 0); - return 0; - } - - BackgroundColorSpan *spanPtr = 0; - { - try { - spanPtr = (BackgroundColorSpan *)new BackgroundColorSpan( - BackgroundColorSpan::New((Dali::Vector4 const &)*colorPtr)); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void *)spanPtr; -} - -SWIGEXPORT void *SWIGSTDCALL -CSharp_Dali_BackgroundColorSpan_GetBackgroundColor(void *refSpan) { - - BackgroundColorSpan *spanPtr; - Dali::Vector4 result; - - spanPtr = (BackgroundColorSpan *)refSpan; - if (!spanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null BackgroundColorSpan", 0); - return 0; - } - - { - try { - result = spanPtr->GetBackgroundColor(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Vector4((const Dali::Vector4 &)result); -} - -SWIGEXPORT bool SWIGSTDCALL -CSharp_Dali_BackgroundColorSpan_IsBackgroundColorDefined(void *refSpan) { - - BackgroundColorSpan *spanPtr; - bool result = false; - - spanPtr = (BackgroundColorSpan *)refSpan; - if (!spanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null BackgroundColorSpan", 0); - return 0; - } - - { - try { - result = spanPtr->IsBackgroundColorDefined(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -// Italic span - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItalicSpan(void *refSpan) { - ItalicSpan *spanPtr = (ItalicSpan *)0; - spanPtr = (ItalicSpan *)refSpan; - - { - try { - delete spanPtr; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_ItalicSpan_New() { - ItalicSpan *spanPtr = 0; - - { - try { - spanPtr = (ItalicSpan *)new ItalicSpan(ItalicSpan::New()); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void *)spanPtr; -} - -// Bold span - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BoldSpan(void *refSpan) { - - BoldSpan *spanPtr = (BoldSpan *)0; - spanPtr = (BoldSpan *)refSpan; - - { - try { - delete spanPtr; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_BoldSpan_New() { - BoldSpan *spanPtr = 0; - - { - try { - spanPtr = (BoldSpan *)new BoldSpan(BoldSpan::New()); - } - CALL_CATCH_EXCEPTION(0); - } - - return (void *)spanPtr; -} - -// FontSpan -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FontSpan(void *refSpan) { - - FontSpan *spanPtr = (FontSpan *)0; - spanPtr = (FontSpan *)refSpan; - - { - try { - delete spanPtr; - } - - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_FontSpan_New(char *argFamilyName, - float argSize, - int argWeight, - int argWidth, - int argSlant) { - - std::string *familyName = 0; - if (!argFamilyName) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, - "null string", 0); - - return 0; - } - - std::string argFamilyName_str(argFamilyName); - familyName = &argFamilyName_str; - float size = (float)argSize; - - Dali::TextAbstraction::FontWeight::Type weight; - weight = (Dali::TextAbstraction::FontWeight::Type)argWeight; - Dali::TextAbstraction::FontWidth::Type width; - width = (Dali::TextAbstraction::FontWidth::Type)argWidth; - Dali::TextAbstraction::FontSlant::Type slant; - slant = (Dali::TextAbstraction::FontSlant::Type)argSlant; - - FontSpan *spanPtr = 0; - { - try { - spanPtr = (FontSpan *)new FontSpan(FontSpan::New( - (std::string const &)*familyName, size, weight, width, slant)); - } - - CALL_CATCH_EXCEPTION(0); - } - - return (void *)spanPtr; -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_FontSpan_GetFamilyName(void *refSpan) { - - FontSpan *spanPtr; - std::string result; - spanPtr = (FontSpan *)refSpan; - - if (!spanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null FontSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->GetFamilyName(); - } - - CALL_CATCH_EXCEPTION(0); - } - - char *nuiResult = SWIG_csharp_string_callback(result.c_str()); - - return nuiResult; -} - -SWIGEXPORT bool SWIGSTDCALL - -CSharp_Dali_FontSpan_IsFamilyNameDefined(void *refSpan) { - - FontSpan *spanPtr; - bool result = false; - - spanPtr = (FontSpan *)refSpan; - if (!spanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null FontSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->IsFamilyNameDefined(); - } - - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontSpan_GetWeight(void *refSpan) { - - FontSpan *spanPtr; - Dali::TextAbstraction::FontWeight::Type result; - - spanPtr = (FontSpan *)refSpan; - if (!spanPtr) { - - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null FontSpan", 0); - - return 0; - } - - { - - try { - result = (Dali::TextAbstraction::FontWeight::Type)spanPtr->GetWeight(); - } - - CALL_CATCH_EXCEPTION(0); - } - - int nuiResult = (int)result; - return nuiResult; -} - -SWIGEXPORT bool SWIGSTDCALL -CSharp_Dali_FontSpan_IsWeightDefined(void *refSpan) { - - FontSpan *spanPtr; - bool result = false; - - spanPtr = (FontSpan *)refSpan; - if (!spanPtr) { - - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null FontSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->IsWeightDefined(); - } - - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontSpan_GetWidth(void *refSpan) { - - FontSpan *spanPtr; - - Dali::TextAbstraction::FontWidth::Type result; - - spanPtr = (FontSpan *)refSpan; - if (!spanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null FontSpan", 0); - - return 0; - } - - { - try { - result = (Dali::TextAbstraction::FontWidth::Type)spanPtr->GetWidth(); - } - - CALL_CATCH_EXCEPTION(0); - } - - int nuiResult = (int)result; - return nuiResult; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FontSpan_IsWidthDefined(void *refSpan) { - - FontSpan *spanPtr; - bool result = false; - - spanPtr = (FontSpan *)refSpan; - if (!spanPtr) { - - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null FontSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->IsWidthDefined(); - } - - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FontSpan_GetSlant(void *refSpan) { - - FontSpan *spanPtr; - Dali::TextAbstraction::FontSlant::Type result; - - spanPtr = (FontSpan *)refSpan; - if (!spanPtr) { - - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null FontSpan", 0); - - return 0; - } - - { - - try { - result = (Dali::TextAbstraction::FontSlant::Type)spanPtr->GetSlant(); - } - - CALL_CATCH_EXCEPTION(0); - } - - int nuiResult = (int)result; - return nuiResult; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FontSpan_IsSlantDefined(void *refSpan) { - - FontSpan *spanPtr; - bool result = false; - - spanPtr = (FontSpan *)refSpan; - if (!spanPtr) { - - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null FontSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->IsSlantDefined(); - } - - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FontSpan_GetSize(void *refSpan) { - - FontSpan *spanPtr; - float result; - - spanPtr = (FontSpan *)refSpan; - if (!spanPtr) { - - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null FontSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->GetSize(); - } - - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FontSpan_IsSizeDefined(void *refSpan) { - - FontSpan *spanPtr; - bool result = false; - - spanPtr = (FontSpan *)refSpan; - if (!spanPtr) { - - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null FontSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->IsSizeDefined(); - } - - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -// UnderlineSpan - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_UnderlineSpan(void *refSpan) { - - UnderlineSpan *spanPtr = (UnderlineSpan *)0; - spanPtr = (UnderlineSpan *)refSpan; - { - try { - delete spanPtr; - } - - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_UnderlineSpan_New() { - - UnderlineSpan *spanPtr = 0; - - { - try { - spanPtr = (UnderlineSpan *)new UnderlineSpan(UnderlineSpan::New()); - } - - CALL_CATCH_EXCEPTION(0); - } - - return (void *)spanPtr; -} - -SWIGEXPORT void *SWIGSTDCALL -CSharp_Dali_UnderlineSpan_NewSolid(void *argColor, float argHeight) { - - float height = (float)argHeight; - Dali::Vector4 *colorPtr = 0; - colorPtr = (Dali::Vector4 *)argColor; - - if (!colorPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::Vector4", 0); - - return 0; - } - - UnderlineSpan *spanPtr = 0; - { - try { - spanPtr = (UnderlineSpan *)new UnderlineSpan( - UnderlineSpan::NewSolid((Dali::Vector4 const &)*colorPtr, height)); - } - - CALL_CATCH_EXCEPTION(0); - } - - return (void *)spanPtr; -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_UnderlineSpan_NewDashed( - void *argColor, float argHeight, float argDashGap, float argDashWidth) { - - float height = (float)argHeight; - float dashGap = (float)argDashGap; - float dashWidth = (float)argDashWidth; - - Dali::Vector4 *colorPtr = 0; - colorPtr = (Dali::Vector4 *)argColor; - - if (!colorPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::Vector4", 0); - - return 0; - } - - UnderlineSpan *spanPtr = 0; - { - try { - spanPtr = (UnderlineSpan *)new UnderlineSpan(UnderlineSpan::NewDashed( - (Dali::Vector4 const &)*colorPtr, height, dashGap, dashWidth)); - } - - CALL_CATCH_EXCEPTION(0); - } - - return (void *)spanPtr; -} - -SWIGEXPORT void *SWIGSTDCALL -CSharp_Dali_UnderlineSpan_NewDouble(void *argColor, float argHeight) { - - float height = (float)argHeight; - Dali::Vector4 *colorPtr = 0; - colorPtr = (Dali::Vector4 *)argColor; - - if (!colorPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::Vector4", 0); - - return 0; - } - - UnderlineSpan *spanPtr = 0; - { - try { - spanPtr = (UnderlineSpan *)new UnderlineSpan( - UnderlineSpan::NewDouble((Dali::Vector4 const &)*colorPtr, height)); - } - - CALL_CATCH_EXCEPTION(0); - } - - return (void *)spanPtr; -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_UnderlineSpan_GetColor(void *refSpan) { - - UnderlineSpan *spanPtr; - Dali::Vector4 result; - - spanPtr = (UnderlineSpan *)refSpan; - if (!spanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null UnderlineSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->GetColor(); - } - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Vector4((const Dali::Vector4 &)result); -} - -SWIGEXPORT bool SWIGSTDCALL - -CSharp_Dali_UnderlineSpan_IsColorDefined(void *refSpan) { - - UnderlineSpan *spanPtr; - bool result = false; - spanPtr = (UnderlineSpan *)refSpan; - - if (!spanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null UnderlineSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->IsColorDefined(); - } - - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_UnderlineSpan_GetType(void *refSpan) { - - UnderlineSpan *spanPtr; - Dali::Toolkit::Text::Underline::Type result; - - spanPtr = (UnderlineSpan *)refSpan; - if (!spanPtr) { - - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null UnderlineSpan", 0); - - return 0; - } - - { - try { - result = (Dali::Toolkit::Text::Underline::Type)spanPtr->GetType(); - } - - CALL_CATCH_EXCEPTION(0); - } - - int nuiResult = (int)result; - return nuiResult; -} - -SWIGEXPORT bool SWIGSTDCALL -CSharp_Dali_UnderlineSpan_IsTypeDefined(void *refSpan) { - - UnderlineSpan *spanPtr; - bool result = false; - - spanPtr = (UnderlineSpan *)refSpan; - if (!spanPtr) { - - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null UnderlineSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->IsTypeDefined(); - } - - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT float SWIGSTDCALL -CSharp_Dali_UnderlineSpan_GetHeight(void *refSpan) { - - UnderlineSpan *spanPtr; - float result; - - spanPtr = (UnderlineSpan *)refSpan; - if (!spanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null UnderlineSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->GetHeight(); - } - - CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL -CSharp_Dali_UnderlineSpan_IsHeightDefined(void *refSpan) { - - UnderlineSpan *spanPtr; - bool result = false; - - spanPtr = (UnderlineSpan *)refSpan; - if (!spanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null UnderlineSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->IsHeightDefined(); - } - - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT float SWIGSTDCALL -CSharp_Dali_UnderlineSpan_GetDashGap(void *refSpan) { - - UnderlineSpan *spanPtr; - float result; - - spanPtr = (UnderlineSpan *)refSpan; - if (!spanPtr) { - - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null UnderlineSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->GetDashGap(); - } - - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL -CSharp_Dali_UnderlineSpan_IsDashGapDefined(void *refSpan) { - - UnderlineSpan *spanPtr; - bool result = false; - - spanPtr = (UnderlineSpan *)refSpan; - if (!spanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null UnderlineSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->IsDashGapDefined(); - } - - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT float SWIGSTDCALL -CSharp_Dali_UnderlineSpan_GetDashWidth(void *refSpan) { - - UnderlineSpan *spanPtr; - float result; - - spanPtr = (UnderlineSpan *)refSpan; - if (!spanPtr) { - - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null UnderlineSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->GetDashWidth(); - } - - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL -CSharp_Dali_UnderlineSpan_IsDashWidthDefined(void *refSpan) { - - UnderlineSpan *spanPtr; - bool result = false; - - spanPtr = (UnderlineSpan *)refSpan; - if (!spanPtr) { - - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null UnderlineSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->IsDashWidthDefined(); - } - - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -// StrikethroughSpan - -SWIGEXPORT void SWIGSTDCALL -CSharp_Dali_delete_StrikethroughSpan(void *refSpan) { - - StrikethroughSpan *spanPtr = (StrikethroughSpan *)0; - spanPtr = (StrikethroughSpan *)refSpan; - { - try { - delete spanPtr; - } - - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_StrikethroughSpan_New() { - - StrikethroughSpan *spanPtr = 0; - { - try { - spanPtr = - (StrikethroughSpan *)new StrikethroughSpan(StrikethroughSpan::New()); - } - - CALL_CATCH_EXCEPTION(0); - } - - return (void *)spanPtr; -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_StrikethroughSpan_New_color_height( - void *argColor, float argHeight) { - - float height = (float)argHeight; - Dali::Vector4 *colorPtr = 0; - colorPtr = (Dali::Vector4 *)argColor; - - if (!colorPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null Dali::Vector4", 0); - - return 0; - } - - StrikethroughSpan *spanPtr = 0; - { - try { - spanPtr = (StrikethroughSpan *)new StrikethroughSpan( - StrikethroughSpan::New((Dali::Vector4 const &)*colorPtr, height)); - } - - CALL_CATCH_EXCEPTION(0); - } - - return (void *)spanPtr; -} - -SWIGEXPORT void *SWIGSTDCALL -CSharp_Dali_StrikethroughSpan_GetColor(void *refSpan) { - - StrikethroughSpan *spanPtr; - Dali::Vector4 result; - - spanPtr = (StrikethroughSpan *)refSpan; - if (!spanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null StrikethroughSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->GetColor(); - } - - CALL_CATCH_EXCEPTION(0); - } - - return new Dali::Vector4((const Dali::Vector4 &)result); -} - -SWIGEXPORT bool SWIGSTDCALL -CSharp_Dali_StrikethroughSpan_IsColorDefined(void *refSpan) { - - StrikethroughSpan *spanPtr; - bool result = false; - - spanPtr = (StrikethroughSpan *)refSpan; - if (!spanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null StrikethroughSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->IsColorDefined(); - } - - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT float SWIGSTDCALL -CSharp_Dali_StrikethroughSpan_GetHeight(void *refSpan) { - - StrikethroughSpan *spanPtr; - float result; - - spanPtr = (StrikethroughSpan *)refSpan; - if (!spanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null StrikethroughSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->GetHeight(); - } - - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT bool SWIGSTDCALL -CSharp_Dali_StrikethroughSpan_IsHeightDefined(void *refSpan) { - - StrikethroughSpan *spanPtr; - bool result = false; - - spanPtr = (StrikethroughSpan *)refSpan; - if (!spanPtr) { - SWIG_CSharpSetPendingExceptionArgument( - SWIG_CSharpArgumentNullException, - "Attempt to dereference null StrikethroughSpan", 0); - - return 0; - } - - { - try { - result = spanPtr->IsHeightDefined(); - } - - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/text-utils-wrap.cpp b/dali-csharp-binder/src/text-utils-wrap.cpp deleted file mode 100755 index f450333d..00000000 --- a/dali-csharp-binder/src/text-utils-wrap.cpp +++ /dev/null @@ -1,870 +0,0 @@ -/* - * Copyright (c) 2020 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RendererParameters_0() { - void * jresult ; - Dali::Toolkit::DevelText::RendererParameters *result = 0 ; - { - try { - result = (Dali::Toolkit::DevelText::RendererParameters *)new Dali::Toolkit::DevelText::RendererParameters(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RendererParameters(void * jarg1) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_text_set(void * jarg1, char * jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - std::string arg2_str(jarg2); - arg2 = &arg2_str; - try { - if (arg1) (arg1)->text = *arg2; - } CALL_CATCH_EXCEPTION(); -} - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_RendererParameters_text_get(void * jarg1) { - char * jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - std::string * result = 0; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - try { - result = (std::string *) & ((arg1)->text); - } CALL_CATCH_EXCEPTION(0); - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_horizontalAlignment_set(void * jarg1, char * jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - std::string arg2_str(jarg2); - arg2 = &arg2_str; - if (arg1) (arg1)->horizontalAlignment = *arg2; -} - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_RendererParameters_horizontalAlignment_get(void * jarg1) { - char * jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - std::string * result = 0; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - try { - result = (std::string *) & ((arg1)->horizontalAlignment); - } CALL_CATCH_EXCEPTION(0); - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_verticalAlignment_set(void * jarg1, char * jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - std::string arg2_str(jarg2); - arg2 = &arg2_str; - if (arg1) (arg1)->verticalAlignment = *arg2; -} - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_RendererParameters_verticalAlignment_get(void * jarg1) { - char * jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - std::string * result = 0; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - try { - result = (std::string *) & ((arg1)->verticalAlignment); - } CALL_CATCH_EXCEPTION(0); - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_fontFamily_set(void * jarg1, char * jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - std::string arg2_str(jarg2); - arg2 = &arg2_str; - if (arg1) (arg1)->fontFamily = * arg2; -} - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_RendererParameters_fontFamily_get(void * jarg1) { - char * jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - std::string * result = 0; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - try { - result = (std::string *) &((arg1)->fontFamily); - } CALL_CATCH_EXCEPTION(0); - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_fontWeight_set(void * jarg1, char * jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - std::string arg2_str(jarg2); - arg2 = &arg2_str; - if (arg1) (arg1)->fontWeight = *arg2; -} - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_RendererParameters_fontWeight_get(void * jarg1) { - char * jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - std::string * result = 0; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - try { - result = (std::string *) &((arg1)->fontWeight); - } CALL_CATCH_EXCEPTION(0); - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_fontWidth_set(void * jarg1, char * jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - std::string arg2_str(jarg2); - arg2 = &arg2_str; - if (arg1) (arg1)->fontWidth = *arg2; -} - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_RendererParameters_fontWidth_get(void * jarg1) { - char * jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - std::string * result = 0; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - try { - result = (std::string *) &((arg1)->fontWidth); - } CALL_CATCH_EXCEPTION(0); - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_fontSlant_set(void * jarg1, char * jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - std::string arg2_str(jarg2); - arg2 = &arg2_str; - if (arg1) (arg1)->fontSlant = *arg2; -} - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_RendererParameters_fontSlant_get(void * jarg1) { - char * jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - std::string * result = 0; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - try { - result = (std::string *) & ((arg1)->fontSlant); - } CALL_CATCH_EXCEPTION(0); - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_layout_set(void * jarg1, char * jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - std::string arg2_str(jarg2); - arg2 = &arg2_str; - if (arg1) (arg1)->layout = *arg2; -} - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_RendererParameters_layout_get(void * jarg1) { - char * jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - std::string * result = 0; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - try { - result = (std::string *) & ((arg1)->layout); - } CALL_CATCH_EXCEPTION(0); - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_circularAlignment_set(void * jarg1, char * jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - std::string arg2_str(jarg2); - arg2 = &arg2_str; - if (arg1) (arg1)->circularAlignment = *arg2; -} - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_RendererParameters_circularAlignment_get(void * jarg1) { - char * jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - std::string * result = 0; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - try { - result = (std::string *) & ((arg1)->circularAlignment); - } CALL_CATCH_EXCEPTION(0); - jresult = SWIG_csharp_string_callback(result->c_str()); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_textColor_set(void * jarg1, void * jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - Dali::Vector4 *arg2 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (arg1) (arg1)->textColor = *arg2; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RendererParameters_textColor_get(void * jarg1) { - void * jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - Dali::Vector4* result; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - result = (Dali::Vector4 *) new Dali::Vector4((arg1)->textColor); - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_fontSize_set(void * jarg1, float jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->fontSize = arg2; -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RendererParameters_fontSize_get(void * jarg1) { - float jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - float result; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - result = (float) ((arg1)->fontSize); - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_textWidth_set(void * jarg1, unsigned int jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - arg2 = (unsigned int)jarg2; - if (arg1) (arg1)->textWidth = arg2; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RendererParameters_textWidth_get(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - result = (unsigned int) ((arg1)->textWidth); - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_textHeight_set(void * jarg1, unsigned int jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - arg2 = (unsigned int)jarg2; - if (arg1) (arg1)->textHeight = arg2; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RendererParameters_textHeight_get(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - result = (unsigned int) ((arg1)->textHeight); - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_radius_set(void * jarg1, unsigned int jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - unsigned int arg2 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - arg2 = (unsigned int)jarg2; - if (arg1) (arg1)->radius = arg2; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RendererParameters_radius_get(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - unsigned int result; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - result = (unsigned int) ((arg1)->radius); - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_beginAngle_set(void * jarg1, float jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->beginAngle = arg2; -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RendererParameters_beginAngle_get(void * jarg1) { - float jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - float result; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - result = (float) ((arg1)->beginAngle); - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_incrementAngle_set(void * jarg1, float jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->incrementAngle = arg2; -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RendererParameters_incrementAngle_get(void * jarg1) { - float jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - float result; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - result = (float) ((arg1)->incrementAngle); - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_ellipsisEnabled_set(void * jarg1, bool jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - bool arg2 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - arg2 = (bool)jarg2; - if (arg1) (arg1)->ellipsisEnabled = arg2; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RendererParameters_ellipsisEnabled_get(void * jarg1) { - bool jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - result = (bool) ((arg1)->ellipsisEnabled); - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_markupEnabled_set(void * jarg1, bool jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - bool arg2 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - arg2 = (bool)jarg2; - if (arg1) (arg1)->markupEnabled = arg2; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RendererParameters_markupEnabled_get(void * jarg1) { - bool jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - result = (bool) ((arg1)->markupEnabled); - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_isTextColorSet_set(void * jarg1, bool jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - bool arg2 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - arg2 = (bool)jarg2; - if (arg1) (arg1)->isTextColorSet = arg2; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RendererParameters_isTextColorSet_get(void * jarg1) { - bool jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - result = (bool) ((arg1)->isTextColorSet); - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_minLineSize_set(void * jarg1, float jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - float arg2 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - arg2 = (float)jarg2; - if (arg1) (arg1)->minLineSize = arg2; -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RendererParameters_minLineSize_get(void * jarg1) { - float jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - float result; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - result = (float) ((arg1)->minLineSize); - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RendererParameters_padding_set(void * jarg1, void * jarg2) { - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - Dali::Extents *arg2 ; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - arg2 = (Dali::Extents *)jarg2; - if (arg1) (arg1)->padding = *arg2; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RendererParameters_padding_get(void * jarg1) { - void * jresult ; - Dali::Toolkit::DevelText::RendererParameters *arg1 = (Dali::Toolkit::DevelText::RendererParameters *) 0 ; - Dali::Extents * result; - - arg1 = (Dali::Toolkit::DevelText::RendererParameters *)jarg1; - result = (Dali::Extents *) new Dali::Extents((arg1)->padding); - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EmbeddedItemInfo_0() { - void * jresult ; - Dali::Toolkit::DevelText::EmbeddedItemInfo *result = 0 ; - { - try { - result = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)new Dali::Toolkit::DevelText::EmbeddedItemInfo(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EmbeddedItemInfo(void * jarg1) { - Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; - - arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_characterIndex_set(void * jarg1, Dali::TextAbstraction::CharacterIndex jarg2) { - Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; - Dali::TextAbstraction::CharacterIndex arg2 ; - - arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; - arg2 = (Dali::TextAbstraction::CharacterIndex)jarg2; - if (arg1) (arg1)->characterIndex = arg2; -} - -SWIGEXPORT Dali::TextAbstraction::CharacterIndex SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_characterIndex_get(void * jarg1) { - Dali::TextAbstraction::CharacterIndex jresult ; - Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; - Dali::TextAbstraction::CharacterIndex result; - - arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; - result = (Dali::TextAbstraction::CharacterIndex) ((arg1)->characterIndex); - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_glyphIndex_set(void * jarg1, Dali::TextAbstraction::GlyphIndex jarg2) { - Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; - Dali::TextAbstraction::GlyphIndex arg2 ; - - arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; - arg2 = (Dali::TextAbstraction::GlyphIndex)jarg2; - if (arg1) (arg1)->glyphIndex = arg2; -} - -SWIGEXPORT Dali::TextAbstraction::GlyphIndex SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_glyphIndex_get(void * jarg1) { - Dali::TextAbstraction::GlyphIndex jresult ; - Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; - Dali::TextAbstraction::GlyphIndex result; - - arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; - result = (Dali::TextAbstraction::GlyphIndex) ((arg1)->glyphIndex); - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_position_set(void * jarg1, void * jarg2) { - Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; - Dali::Vector2 * arg2 ; - - arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (arg1) (arg1)->position = *arg2; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_position_get(void * jarg1) { - void * jresult ; - Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; - Dali::Vector2 * result; - - arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; - result = (Dali::Vector2 *) & ((arg1)->position); - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_size_set(void * jarg1, void * jarg2) { - Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; - Dali::Size* arg2 ; - - arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; - arg2 = (Dali::Size *)jarg2; - if (arg1) (arg1)->size = *arg2; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_size_get(void * jarg1) { - void * jresult ; - Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; - Dali::Size * result; - - arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; - result = (Dali::Size *) & ((arg1)->size); - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_rotatedSize_set(void * jarg1, void * jarg2) { - Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; - Dali::Size * arg2 ; - - arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; - arg2 = (Dali::Size *)jarg2; - if (arg1) (arg1)->rotatedSize = * arg2; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_rotatedSize_get(void * jarg1) { - void * jresult ; - Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; - Dali::Size * result; - - arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; - result = (Dali::Size *) & ((arg1)->rotatedSize); - jresult = (void *) result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_angle_set(void * jarg1, void * jarg2) { - Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; - Dali::Degree *arg2 ; - - arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; - arg2 = (Dali::Degree *)jarg2; - if (arg1) (arg1)->angle = *arg2; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_angle_get(void * jarg1) { - void * jresult ; - Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; - Dali::Degree * result; - - arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; - result = (Dali::Degree *) & ((arg1)->angle); - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_colorBlendingMode_set(void * jarg1, Dali::TextAbstraction::ColorBlendingMode jarg2) { - Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; - Dali::TextAbstraction::ColorBlendingMode arg2 ; - - arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; - arg2 = (Dali::TextAbstraction::ColorBlendingMode)jarg2; - if (arg1) (arg1)->colorBlendingMode = arg2; -} - -SWIGEXPORT Dali::TextAbstraction::ColorBlendingMode SWIGSTDCALL CSharp_Dali_EmbeddedItemInfo_colorBlendingMode_get(void * jarg1) { - Dali::TextAbstraction::ColorBlendingMode jresult ; - Dali::Toolkit::DevelText::EmbeddedItemInfo *arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *) 0 ; - Dali::TextAbstraction::ColorBlendingMode result; - - arg1 = (Dali::Toolkit::DevelText::EmbeddedItemInfo *)jarg1; - result = (Dali::TextAbstraction::ColorBlendingMode) ((arg1)->colorBlendingMode); - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ShadowParameters_0() { - void * jresult ; - Dali::Toolkit::DevelText::ShadowParameters *result = 0 ; - { - try { - result = (Dali::Toolkit::DevelText::ShadowParameters *)new Dali::Toolkit::DevelText::ShadowParameters(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ShadowParameters(void * jarg1) { - Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; - - arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ShadowParameters_input_set(void * jarg1, void * jarg2) { - Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; - Dali::Devel::PixelBuffer *arg2 ; - - arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; - arg2 = (Dali::Devel::PixelBuffer *)jarg2; - if (arg1) (arg1)->input = *arg2; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ShadowParameters_input_get(void * jarg1) { - void * jresult ; - Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; - Dali::Devel::PixelBuffer result; - - arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; - result = (Dali::Devel::PixelBuffer) ((arg1)->input); - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ShadowParameters_textColor_set(void * jarg1, void * jarg2) { - Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; - Dali::Vector4 *arg2 ; - - arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (arg1) (arg1)->textColor = *arg2; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ShadowParameters_textColor_get(void * jarg1) { - void * jresult ; - Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; - Dali::Vector4 * result; - - arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; - result = (Dali::Vector4 *)new Dali::Vector4((arg1)->textColor); - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ShadowParameters_color_set(void * jarg1, void * jarg2) { - Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; - Dali::Vector4 * arg2 ; - - arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; - arg2 = (Dali::Vector4 *)jarg2; - if (arg1) (arg1)->color = *arg2; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ShadowParameters_color_get(void * jarg1) { - void * jresult ; - Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; - Dali::Vector4 * result; - - arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; - result = (Dali::Vector4 *) & ((arg1)->color); - jresult = (void *) result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ShadowParameters_offset_set(void * jarg1, void * jarg2) { - Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; - Dali::Vector2 * arg2 ; - - arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; - arg2 = (Dali::Vector2 *)jarg2; - if (arg1) (arg1)->offset = *arg2; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ShadowParameters_offset_get(void * jarg1) { - void * jresult ; - Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; - Dali::Vector2 * result; - - arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; - result = (Dali::Vector2 *) & ((arg1)->offset); - jresult = (void *) result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ShadowParameters_blendShadow_set(void * jarg1, bool jarg2) { - Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; - bool arg2 ; - - arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; - arg2 = (bool)jarg2; - if (arg1) (arg1)->blendShadow = arg2; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ShadowParameters_blendShadow_get(void * jarg1) { - bool jresult ; - Dali::Toolkit::DevelText::ShadowParameters *arg1 = (Dali::Toolkit::DevelText::ShadowParameters *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::DevelText::ShadowParameters *)jarg1; - result = (bool) ((arg1)->blendShadow); - jresult = result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextUtils_Render(void* jarg1, void** jarg2, int* jarg3, int* jarg4) { - void* jresult; - Dali::Toolkit::DevelText::RendererParameters* arg1 = (Dali::Toolkit::DevelText::RendererParameters*)(jarg1); - - Dali::Vector embeddedItemLayout; - - Dali::Devel::PixelBuffer result = Dali::Toolkit::DevelText::Render(*arg1, embeddedItemLayout); - void** arg2 = jarg2; - uint16_t* arg3 = (uint16_t*)(jarg3); - uint16_t* arg4 = (uint16_t*)(jarg4); - - Dali::Toolkit::DevelText::EmbeddedItemInfo* array = new Dali::Toolkit::DevelText::EmbeddedItemInfo[embeddedItemLayout.Count()]; - int count = 0; - for( const auto& itemLayout : embeddedItemLayout ) - { - array[count++] = itemLayout; - } - *arg2 = (void *) array; - *arg3 = count; - *arg4 = sizeof(struct Dali::Toolkit::DevelText::EmbeddedItemInfo); - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextUtils_CreateShadow(void* jarg1) { - void* jresult; - Dali::Toolkit::DevelText::ShadowParameters* arg1 = (Dali::Toolkit::DevelText::ShadowParameters*)(jarg1); - - Dali::Devel::PixelBuffer result = Dali::Toolkit::DevelText::CreateShadow(*arg1); - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextUtils_ConvertToRgba8888(void* jarg1, void* jarg2, bool jarg3 ) { - void* jresult; - Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *)jarg1; - Dali::Vector4 *arg2 = (Dali::Vector4 *)jarg2; - bool arg3 = (bool)jarg3; - - Dali::Devel::PixelBuffer result = Dali::Toolkit::DevelText::ConvertToRgba8888(*arg1, *arg2, arg3); - jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextUtils_UpdateBuffer(void* jarg1, void* jarg2, unsigned int jarg3, unsigned int jarg4, bool jarg5) { - Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *)jarg1; - Dali::Devel::PixelBuffer *arg2 = (Dali::Devel::PixelBuffer *)jarg2; - unsigned int arg3 = (unsigned int)jarg3; - unsigned int arg4 = (unsigned int)jarg4; - bool arg5 = (bool)jarg5; - - Dali::Toolkit::DevelText::UpdateBuffer(*arg1, *arg2, arg3, arg4, arg5); -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextUtils_GetLastCharacterIndex(void* jarg1) { - void* jresult; - Dali::Property::Array *result = 0 ; - Dali::Toolkit::DevelText::RendererParameters* arg1 = (Dali::Toolkit::DevelText::RendererParameters*)(jarg1); - - if(!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelText::RendererParameters is null", 0); - result = (Dali::Property::Array *)new Dali::Property::Array(); - jresult = (void *)result; - return jresult; - } - - try { - Dali::Property::Array result1 = Dali::Toolkit::DevelText::GetLastCharacterIndex(*arg1); - result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)result1); - } CALL_CATCH_EXCEPTION(0); - jresult = (void *)result; - return jresult; -} - - - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/tizen-dependency-wrap.cpp b/dali-csharp-binder/src/tizen-dependency-wrap.cpp deleted file mode 100644 index 06eb44c8..00000000 --- a/dali-csharp-binder/src/tizen-dependency-wrap.cpp +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Copyright (c) 2020 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Texture_TbmSurface(tbm_surface_h tbm_surface) { - Dali::NativeImageSourcePtr mNativeImageSrc; - Dali::Texture mNativeTexture; - void * jresult ; - - if (!tbm_surface) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "tbm surface is null", 0); - return 0; - } - - try { - Dali::Any source(tbm_surface); - mNativeImageSrc = Dali::NativeImageSource::New(source); - mNativeTexture = Dali::Texture::New( *mNativeImageSrc ); - } CALL_CATCH_EXCEPTION(0); - - jresult = new Dali::Texture((const Dali::Texture &)mNativeTexture); - return (void*)jresult; -} - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/transition-base-wrap.cpp b/dali-csharp-binder/src/transition-base-wrap.cpp deleted file mode 100755 index 0dd026e6..00000000 --- a/dali-csharp-binder/src/transition-base-wrap.cpp +++ /dev/null @@ -1,230 +0,0 @@ -/* - * Copyright (c) 2021 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_TransitionBase() - { - void *jresult; - Dali::Toolkit::TransitionBase *result = 0; - - { - try - { - result = (Dali::Toolkit::TransitionBase *)new Dali::Toolkit::TransitionBase(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_TransitionBase_New() - { - void *jresult; - Dali::Toolkit::TransitionBase result; - { - try - { - result = Dali::Toolkit::TransitionBase::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::TransitionBase((const Dali::Toolkit::TransitionBase &)result); - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionBase(void *nuiTransitionBase) - { - Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)0; - - transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase; - { - try - { - delete transition; - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_TransitionBase_Set(void *nuiTransitionBase) - { - Dali::Toolkit::TransitionBase *newTransition = 0; - Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase; - if (!transition) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionBase const & type is null", 0); - return 0; - } - { - try - { - newTransition = (Dali::Toolkit::TransitionBase *)new Dali::Toolkit::TransitionBase((Dali::Toolkit::TransitionBase const &)*transition); - } - CALL_CATCH_EXCEPTION(0); - } - void *result; - result = (void *)newTransition; - return result; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_TransitionBase_Assign(void *nuiDestination, void *nuiSource) - { - void *jresult; - Dali::Toolkit::TransitionBase *destination = (Dali::Toolkit::TransitionBase *)0; - Dali::Toolkit::TransitionBase *source = 0; - Dali::Toolkit::TransitionBase *result = 0; - - destination = (Dali::Toolkit::TransitionBase *)nuiDestination; - source = (Dali::Toolkit::TransitionBase *)nuiSource; - - if (!source) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionBase const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Toolkit::TransitionBase *)&(destination)->operator=((Dali::Toolkit::TransitionBase const &)*source); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TransitionBase_SetTimePeriod(void *nuiTransitionBase, void *nuiTimePeriod) - { - Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase; - Dali::TimePeriod *timePeriod = (Dali::TimePeriod *)nuiTimePeriod; - - if (!transition || !timePeriod) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); - return; - } - { - try - { - (transition)->SetTimePeriod(*timePeriod); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_TransitionBase_GetTimePeriod(void *nuiTransitionBase) - { - Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase; - Dali::TimePeriod timePeriod(0); - { - try - { - timePeriod = ((Dali::Toolkit::TransitionBase const *)transition)->GetTimePeriod(); - } - CALL_CATCH_EXCEPTION(0); - } - void *result = new Dali::TimePeriod((const Dali::TimePeriod &)timePeriod); - return result; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TransitionBase_SetAlphaFunction(void *nuiTransitionBase, void *nuiAlphaFunction) - { - Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase; - Dali::AlphaFunction *alphaFunction = (Dali::AlphaFunction *)nuiAlphaFunction; - - if (!transition || !alphaFunction) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); - return; - } - { - try - { - (transition)->SetAlphaFunction(*alphaFunction); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_TransitionBase_GetAlphaFunction(void *nuiTransitionBase) - { - Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase; - Dali::AlphaFunction alphaFunction; - { - try - { - alphaFunction = ((Dali::Toolkit::TransitionBase const *)transition)->GetAlphaFunction(); - } - CALL_CATCH_EXCEPTION(0); - } - void *result = new Dali::AlphaFunction((const Dali::AlphaFunction &)alphaFunction); - return result; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TransitionBase_TransitionWithChild(void *nuiTransitionBase, bool nuiTransitionWithChild) - { - Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase; - - if (!transition) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); - return; - } - { - try - { - (transition)->TransitionWithChild(nuiTransitionWithChild); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TransitionBase_SetAppearingTransition(void *nuiTransitionBase, bool nuiAppearingTransition) - { - Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransitionBase; - - if (!transition) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); - return; - } - { - try - { - (transition)->SetAppearingTransition(nuiAppearingTransition); - } - CALL_CATCH_EXCEPTION(); - } - } - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/transition-effects-wrap.cpp b/dali-csharp-binder/src/transition-effects-wrap.cpp deleted file mode 100755 index 5f81724d..00000000 --- a/dali-csharp-binder/src/transition-effects-wrap.cpp +++ /dev/null @@ -1,503 +0,0 @@ -/* - * Copyright (c) 2019 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__Empty(Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > const *self) { - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__GetConnectionCount(Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > const *self) { - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__Connect(Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *self, void(*func)(Dali::Toolkit::CubeTransitionEffect)) { - self->Connect(func); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__Disconnect(Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *self, void(*func)(Dali::Toolkit::CubeTransitionEffect)) { - self->Disconnect(func); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__Emit(Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *self, Dali::Toolkit::CubeTransitionEffect arg) { - self->Emit(arg); -} - - -#ifdef __cplusplus -extern "C" { -#endif - -// cube-transition-effect.h - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_SWIGUpcast(Dali::Toolkit::CubeTransitionEffect *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CubeTransitionEffect() { - Dali::Toolkit::CubeTransitionEffect* result; - - { - try { - result = new Dali::Toolkit::CubeTransitionEffect(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CubeTransitionEffect(void * jarg1) { - Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; - - arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; - { - try { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_SetTransitionDuration(void * jarg1, float duration) { - Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; - - arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; - { - try { - (arg1)->SetTransitionDuration(duration); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_GetTransitionDuration(void * jarg1) { - Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; - - float result = 0.0f; - arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; - { - try { - result = (arg1)->GetTransitionDuration(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_SetCubeDisplacement(void * jarg1, float displacement) { - Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; - - arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; - { - try { - (arg1)->SetCubeDisplacement(displacement); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_GetCubeDisplacement(void * jarg1) { - Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; - - float result = 0.0f; - arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; - { - try { - result = (arg1)->GetCubeDisplacement(); - } - CALL_CATCH_EXCEPTION(0.0f); - } - - return result; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_IsTransitioning(void * jarg1) { - Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; - - bool result = false; - arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; - { - try { - result = (arg1)->IsTransitioning(); - } - CALL_CATCH_EXCEPTION(false); - } - - unsigned int jresult = result; // convert bool to unsigned int. - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_SetCurrentTexture(void* jarg1, void* jarg2) { - Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; - - arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; - Dali::Texture* argp2 = (Dali::Texture*)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0); - return ; - } - - { - try { - (arg1)->SetCurrentTexture(*argp2); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_SetTargetTexture(void* jarg1, void* jarg2) { - Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; - - arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; - Dali::Texture* argp2 = (Dali::Texture*)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0); - return; - } - - { - try { - (arg1)->SetTargetTexture(*argp2); - } - CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_StartTransition__SWIG1(void* jarg1, bool toNextImage) { - Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; - - arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; - - { - try { - (arg1)->StartTransition(toNextImage); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_StartTransition__SWIG2(void* jarg1, void* jarg2, void* jarg3) { - Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; - - arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; - - Dali::Vector2* argp2 = (Dali::Vector2*)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); - return; - } - - Dali::Vector2* argp3 = (Dali::Vector2*)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); - return; - } - - { - try { - (arg1)->StartTransition(*argp2, *argp3); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_PauseTransition(void * jarg1) { - Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; - - arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; - { - try { - (arg1)->PauseTransition(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_ResumeTransition(void * jarg1) { - Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; - - arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; - { - try { - (arg1)->ResumeTransition(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_StopTransition(void * jarg1) { - Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; - - arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; - { - try { - (arg1)->StopTransition(); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CubeTransitionEffect_TransitionCompletedSignal(void * jarg1) { - void * jresult; - Dali::Toolkit::CubeTransitionEffect *arg1 = (Dali::Toolkit::CubeTransitionEffect *) 0; - Dali::Toolkit::CubeTransitionEffect::TransitionCompletedSignalType *result = 0; - - arg1 = (Dali::Toolkit::CubeTransitionEffect *)jarg1; - { - try { - result = (Dali::Toolkit::CubeTransitionEffect::TransitionCompletedSignalType *) &(arg1)->TransitionCompletedSignal(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CubeTransitionEffectSignal_Empty(void * jarg1) { - unsigned int jresult; - Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *) 0; - bool result; - - arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__Empty((Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > const *)arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_CubeTransitionEffectSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult; - Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *) 0; - std::size_t result; - - arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__GetConnectionCount((Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > const *)arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffectSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *) 0; - void(*arg2)(Dali::Toolkit::CubeTransitionEffect) = (void(*)(Dali::Toolkit::CubeTransitionEffect)) 0; - - arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *)jarg1; - arg2 = (void(*)(Dali::Toolkit::CubeTransitionEffect))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__Connect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffectSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *) 0; - void(*arg2)(Dali::Toolkit::CubeTransitionEffect) = (void(*)(Dali::Toolkit::CubeTransitionEffect)) 0; - - arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *)jarg1; - arg2 = (void(*)(Dali::Toolkit::CubeTransitionEffect))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__Disconnect(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CubeTransitionEffectSignal_Emit(void * jarg1, void * jarg2) { - Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *) 0; - Dali::Toolkit::CubeTransitionEffect arg2; - Dali::Toolkit::CubeTransitionEffect *argp2; - - arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *)jarg1; - argp2 = (Dali::Toolkit::CubeTransitionEffect *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::CubeTransitionEffect", 0); - return; - } - arg2 = *argp2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Toolkit_CubeTransitionEffect_SP__Sg__Emit(arg1, arg2); - } - CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CubeTransitionEffectSignal() { - void * jresult; - Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *result = 0; - - { - try { - result = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *)new Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) >(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CubeTransitionEffectSignal(void * jarg1) { - Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *) 0; - - arg1 = (Dali::Signal< void(Dali::Toolkit::CubeTransitionEffect) > *)jarg1; - { - try { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } - -} - - -// cube-transition-cross-effect.h - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_CubeTransitionCrossEffect_SWIGUpcast(Dali::Toolkit::CubeTransitionCrossEffect *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CubeTransitionCrossEffect_New(unsigned int numRows, unsigned int numColumns) { - void * jresult; - Dali::Toolkit::CubeTransitionEffect result; - - { - try { - result = Dali::Toolkit::CubeTransitionCrossEffect::New(numRows, numColumns); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::CubeTransitionCrossEffect((const Dali::Toolkit::CubeTransitionCrossEffect &)result); - - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CubeTransitionCrossEffect(void * jarg1) { - Dali::Toolkit::CubeTransitionCrossEffect *arg1 = (Dali::Toolkit::CubeTransitionCrossEffect *) 0; - - arg1 = (Dali::Toolkit::CubeTransitionCrossEffect *)jarg1; - { - try { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } -} - -// cube-transition-fold-effect.h - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_CubeTransitionFoldEffect_SWIGUpcast(Dali::Toolkit::CubeTransitionFoldEffect *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CubeTransitionFoldEffect_New(unsigned int numRows, unsigned int numColumns) { - void * jresult; - Dali::Toolkit::CubeTransitionEffect result; - - { - try { - result = Dali::Toolkit::CubeTransitionFoldEffect::New(numRows, numColumns); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::CubeTransitionFoldEffect((const Dali::Toolkit::CubeTransitionFoldEffect &)result); - - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CubeTransitionFoldEffect(void * jarg1) { - Dali::Toolkit::CubeTransitionFoldEffect *arg1 = (Dali::Toolkit::CubeTransitionFoldEffect *) 0; - - arg1 = (Dali::Toolkit::CubeTransitionFoldEffect *)jarg1; - { - try { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } -} - -// cube-transition-wave-effect.h - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_CubeTransitionWaveEffect_SWIGUpcast(Dali::Toolkit::CubeTransitionWaveEffect *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CubeTransitionWaveEffect_New(unsigned int numRows, unsigned int numColumns) { - void * jresult; - Dali::Toolkit::CubeTransitionEffect result; - - { - try { - result = Dali::Toolkit::CubeTransitionWaveEffect::New(numRows, numColumns); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::CubeTransitionWaveEffect((const Dali::Toolkit::CubeTransitionWaveEffect &)result); - - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CubeTransitionWaveEffect(void * jarg1) { - Dali::Toolkit::CubeTransitionWaveEffect *arg1 = (Dali::Toolkit::CubeTransitionWaveEffect *) 0; - - arg1 = (Dali::Toolkit::CubeTransitionWaveEffect *)jarg1; - { - try { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } -} - - -#ifdef __cplusplus -} -#endif \ No newline at end of file diff --git a/dali-csharp-binder/src/transition-set-wrap.cpp b/dali-csharp-binder/src/transition-set-wrap.cpp deleted file mode 100755 index d0e24cc6..00000000 --- a/dali-csharp-binder/src/transition-set-wrap.cpp +++ /dev/null @@ -1,280 +0,0 @@ -/* - * Copyright (c) 2021 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -SWIGINTERN bool Dali_TransitionSet_Signal_Empty(Dali::Toolkit::TransitionSet::TransitionSetSignalType const *self) -{ - return self->Empty(); -} - -SWIGINTERN std::size_t Dali_TransitionSet_Signal_GetConnectionCount(Dali::Toolkit::TransitionSet::TransitionSetSignalType const *self) -{ - return self->GetConnectionCount(); -} - -SWIGINTERN void Dali_TransitionSet_Signal_Connect(Dali::Toolkit::TransitionSet::TransitionSetSignalType *self, void (*func)(Dali::Toolkit::TransitionSet &)) -{ - self->Connect(func); -} - -SWIGINTERN void Dali_TransitionSet_Signal_Disconnect(Dali::Toolkit::TransitionSet::TransitionSetSignalType *self, void (*func)(Dali::Toolkit::TransitionSet &)) -{ - self->Disconnect(func); -} - -#ifdef __cplusplus -extern "C" -{ -#endif - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_TransitionSet() - { - void *jresult; - Dali::Toolkit::TransitionSet *result = 0; - { - try - { - result = (Dali::Toolkit::TransitionSet *)new Dali::Toolkit::TransitionSet(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_TransitionSet_New() - { - void *jresult; - Dali::Toolkit::TransitionSet result; - { - try - { - result = Dali::Toolkit::TransitionSet::New(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::TransitionSet((const Dali::Toolkit::TransitionSet &)result); - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionSet(void *nuiTransitionSet) - { - Dali::Toolkit::TransitionSet *transition = (Dali::Toolkit::TransitionSet *)0; - - transition = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; - { - try - { - delete transition; - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_TransitionSet_Set(void *nuiTransitionSet) - { - Dali::Toolkit::TransitionSet *newTransitionSet = 0; - Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; - if (!transitionSet) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionSet const & type is null", 0); - return 0; - } - { - try - { - newTransitionSet = (Dali::Toolkit::TransitionSet *)new Dali::Toolkit::TransitionSet((Dali::Toolkit::TransitionSet const &)*transitionSet); - } - CALL_CATCH_EXCEPTION(0); - } - void *result; - result = (void *)newTransitionSet; - return result; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_TransitionSet_Assign(void *nuiDestination, void *nuiSource) - { - void *jresult; - Dali::Toolkit::TransitionSet *destination = (Dali::Toolkit::TransitionSet *)0; - Dali::Toolkit::TransitionSet *source = 0; - Dali::Toolkit::TransitionSet *result = 0; - - destination = (Dali::Toolkit::TransitionSet *)nuiDestination; - source = (Dali::Toolkit::TransitionSet *)nuiSource; - - if (!source) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionSet const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Toolkit::TransitionSet *)&(destination)->operator=((Dali::Toolkit::TransitionSet const &)*source); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TransitionSet_AddTransition(void *nuiTransitionSet, void *nuiTransition) - { - Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; - Dali::Toolkit::TransitionBase *transition = (Dali::Toolkit::TransitionBase *)nuiTransition; - - if (!transitionSet || !transition) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); - return; - } - { - try - { - (transitionSet)->AddTransition(*transition); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_TransitionSet_GetTransitionAt(void *nuiTransitionSet, unsigned int index) - { - Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; - Dali::Toolkit::TransitionBase transition; - { - try - { - transition = (transitionSet)->GetTransitionAt(index); - } - CALL_CATCH_EXCEPTION(0); - } - Dali::Toolkit::TransitionBase *result = new Dali::Toolkit::TransitionBase((const Dali::Toolkit::TransitionBase &)transition); - return result; - } - - SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TransitionSet_GetTransitionCount(void *nuiTransitionSet) - { - Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; - unsigned int result; - { - try - { - result = (unsigned int)((Dali::Toolkit::TransitionSet const *)transitionSet)->GetTransitionCount(); - } - CALL_CATCH_EXCEPTION(0); - } - return result; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TransitionSet_Play(void *nuiTransitionSet) - { - Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; - - if (!transitionSet) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0); - return; - } - { - try - { - (transitionSet)->Play(); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_TransitionSet_FinishedSignal(void *nuiTransitionSet) - { - Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; - Dali::Toolkit::TransitionSet::TransitionSetSignalType *transitionSetSignalType = 0; - { - try - { - transitionSetSignalType = (Dali::Toolkit::TransitionSet::TransitionSetSignalType *)&(transitionSet)->FinishedSignal(); - } - CALL_CATCH_EXCEPTION(0); - } - void *result = (void *)transitionSetSignalType; - return result; - } - - SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TransitionSet_Signal_Empty(void *nuiTransitionSet) - { - Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; - bool reselt; - { - try - { - reselt = Dali_TransitionSet_Signal_Empty((Dali::Toolkit::TransitionSet::TransitionSetSignalType const *)transitionSet); - } - CALL_CATCH_EXCEPTION(0); - } - return reselt; - } - - SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TransitionSet_Signal_GetConnectionCount(void *nuiTransitionSet) - { - Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; - std::size_t reselt; - { - try - { - reselt = Dali_TransitionSet_Signal_GetConnectionCount((Dali::Toolkit::TransitionSet::TransitionSetSignalType const *)transitionSet); - } - CALL_CATCH_EXCEPTION(0); - } - return reselt; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TransitionSet_Signal_Connect(void *nuiTransitionSet, void *nuiFunc) - { - Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; - void (*func)(Dali::Toolkit::TransitionSet &) = (void (*)(Dali::Toolkit::TransitionSet &))nuiFunc; - { - try - { - Dali_TransitionSet_Signal_Connect((Dali::Toolkit::TransitionSet::TransitionSetSignalType *)transitionSet, func); - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TransitionSet_Signal_Disconnect(void *nuiTransitionSet, void *nuiFunc) - { - Dali::Toolkit::TransitionSet *transitionSet = (Dali::Toolkit::TransitionSet *)nuiTransitionSet; - void (*func)(Dali::Toolkit::TransitionSet &) = (void (*)(Dali::Toolkit::TransitionSet &))nuiFunc; - { - try - { - Dali_TransitionSet_Signal_Disconnect((Dali::Toolkit::TransitionSet::TransitionSetSignalType *)transitionSet, func); - } - CALL_CATCH_EXCEPTION(); - } - } - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/transition-wrap.cpp b/dali-csharp-binder/src/transition-wrap.cpp deleted file mode 100755 index a31d25ac..00000000 --- a/dali-csharp-binder/src/transition-wrap.cpp +++ /dev/null @@ -1,131 +0,0 @@ -/* - * Copyright (c) 2021 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. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_Transition() - { - void *jresult; - Dali::Toolkit::Transition *result = 0; - - { - try - { - result = (Dali::Toolkit::Transition *)new Dali::Toolkit::Transition(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Transition_New(void *nuiSource, void *nuiDestination, bool useDestinationTarget, void *nuiTimePeriod) - { - void *jresult; - Dali::Toolkit::Control *source = (Dali::Toolkit::Control *)nuiSource; - Dali::Toolkit::Control *destination = (Dali::Toolkit::Control *)nuiDestination; - Dali::TimePeriod *timePeriod = (Dali::TimePeriod *)nuiTimePeriod; - - Dali::Toolkit::Transition result; - - { - try - { - result = Dali::Toolkit::Transition::New(*source, *destination, useDestinationTarget, *timePeriod); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::Transition((const Dali::Toolkit::Transition &)result); - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Transition(void *nuiTransition) - { - Dali::Toolkit::Transition *transition = (Dali::Toolkit::Transition *)0; - - transition = (Dali::Toolkit::Transition *)nuiTransition; - { - try - { - delete transition; - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_Transition_Set(void *nuiTransition) - { - Dali::Toolkit::Transition *newTransition = 0; - Dali::Toolkit::Transition *transition = (Dali::Toolkit::Transition *)nuiTransition; - if (!transition) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Transition const & type is null", 0); - return 0; - } - { - try - { - newTransition = (Dali::Toolkit::Transition *)new Dali::Toolkit::Transition((Dali::Toolkit::Transition const &)*transition); - } - CALL_CATCH_EXCEPTION(0); - } - void *result; - result = (void *)newTransition; - return result; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Transition_Assign(void *nuiDestination, void *nuiSource) - { - void *jresult; - Dali::Toolkit::Transition *destination = (Dali::Toolkit::Transition *)0; - Dali::Toolkit::Transition *source = 0; - Dali::Toolkit::Transition *result = 0; - - destination = (Dali::Toolkit::Transition *)nuiDestination; - source = (Dali::Toolkit::Transition *)nuiSource; - - if (!source) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Transition const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::Toolkit::Transition *)&(destination)->operator=((Dali::Toolkit::Transition const &)*source); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/tts-player-wrap.cpp b/dali-csharp-binder/src/tts-player-wrap.cpp deleted file mode 100755 index 0c42ffce..00000000 --- a/dali-csharp-binder/src/tts-player-wrap.cpp +++ /dev/null @@ -1,357 +0,0 @@ -/* - * Copyright (c) 2017 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__Empty(Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > const *self){ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__Connect(Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *self,void (*func)(Dali::TtsPlayer::State const,Dali::TtsPlayer::State const)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__Disconnect(Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *self,void (*func)(Dali::TtsPlayer::State const,Dali::TtsPlayer::State const)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__Emit(Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *self,Dali::TtsPlayer::State const arg1,Dali::TtsPlayer::State const arg2){ - self->Emit( arg1, arg2 ); -} - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TtsPlayer_SWIGUpcast(Dali::TtsPlayer *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TtsPlayer__SWIG_0() { - void * jresult ; - Dali::TtsPlayer *result = 0 ; - - { - try { - result = (Dali::TtsPlayer *)new Dali::TtsPlayer(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TtsPlayer_Get__SWIG_0(int jarg1) { - void * jresult ; - Dali::TtsPlayer::Mode arg1 ; - Dali::TtsPlayer result; - - arg1 = (Dali::TtsPlayer::Mode)jarg1; - { - try { - result = Dali::TtsPlayer::Get(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::TtsPlayer((const Dali::TtsPlayer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TtsPlayer_Get__SWIG_1() { - void * jresult ; - Dali::TtsPlayer result; - - { - try { - result = Dali::TtsPlayer::Get(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::TtsPlayer((const Dali::TtsPlayer &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TtsPlayer(void * jarg1) { - Dali::TtsPlayer *arg1 = (Dali::TtsPlayer *) 0 ; - - arg1 = (Dali::TtsPlayer *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TtsPlayer__SWIG_1(void * jarg1) { - void * jresult ; - Dali::TtsPlayer *arg1 = 0 ; - Dali::TtsPlayer *result = 0 ; - - arg1 = (Dali::TtsPlayer *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TtsPlayer const & type is null", 0); - return 0; - } - { - try { - result = (Dali::TtsPlayer *)new Dali::TtsPlayer((Dali::TtsPlayer const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TtsPlayer_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::TtsPlayer *arg1 = (Dali::TtsPlayer *) 0 ; - Dali::TtsPlayer *arg2 = 0 ; - Dali::TtsPlayer *result = 0 ; - - arg1 = (Dali::TtsPlayer *)jarg1; - arg2 = (Dali::TtsPlayer *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TtsPlayer const & type is null", 0); - return 0; - } - { - try { - result = (Dali::TtsPlayer *) &(arg1)->operator =((Dali::TtsPlayer const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TtsPlayer_Play(void * jarg1, char * jarg2) { - Dali::TtsPlayer *arg1 = (Dali::TtsPlayer *) 0 ; - std::string *arg2 = 0 ; - - arg1 = (Dali::TtsPlayer *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - (arg1)->Play((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TtsPlayer_Stop(void * jarg1) { - Dali::TtsPlayer *arg1 = (Dali::TtsPlayer *) 0 ; - - arg1 = (Dali::TtsPlayer *)jarg1; - { - try { - (arg1)->Stop(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TtsPlayer_Pause(void * jarg1) { - Dali::TtsPlayer *arg1 = (Dali::TtsPlayer *) 0 ; - - arg1 = (Dali::TtsPlayer *)jarg1; - { - try { - (arg1)->Pause(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TtsPlayer_Resume(void * jarg1) { - Dali::TtsPlayer *arg1 = (Dali::TtsPlayer *) 0 ; - - arg1 = (Dali::TtsPlayer *)jarg1; - { - try { - (arg1)->Resume(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TtsPlayer_GetState(void * jarg1) { - int jresult ; - Dali::TtsPlayer *arg1 = (Dali::TtsPlayer *) 0 ; - Dali::TtsPlayer::State result; - - arg1 = (Dali::TtsPlayer *)jarg1; - { - try { - result = (Dali::TtsPlayer::State)(arg1)->GetState(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TtsPlayer_StateChangedSignal(void * jarg1) { - void * jresult ; - Dali::TtsPlayer *arg1 = (Dali::TtsPlayer *) 0 ; - Dali::TtsPlayer::StateChangedSignalType *result = 0 ; - - arg1 = (Dali::TtsPlayer *)jarg1; - { - try { - result = (Dali::TtsPlayer::StateChangedSignalType *) &(arg1)->StateChangedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StateChangedSignalType_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__Empty((Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StateChangedSignalType_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StateChangedSignalType_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *) 0 ; - void (*arg2)(Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) = (void (*)(Dali::TtsPlayer::State const,Dali::TtsPlayer::State const)) 0 ; - - arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *)jarg1; - arg2 = (void (*)(Dali::TtsPlayer::State const,Dali::TtsPlayer::State const))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StateChangedSignalType_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *) 0 ; - void (*arg2)(Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) = (void (*)(Dali::TtsPlayer::State const,Dali::TtsPlayer::State const)) 0 ; - - arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *)jarg1; - arg2 = (void (*)(Dali::TtsPlayer::State const,Dali::TtsPlayer::State const))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StateChangedSignalType_Emit(void * jarg1, int jarg2, int jarg3) { - Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *) 0 ; - Dali::TtsPlayer::State arg2 ; - Dali::TtsPlayer::State arg3 ; - - arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *)jarg1; - arg2 = (Dali::TtsPlayer::State)jarg2; - arg3 = (Dali::TtsPlayer::State)jarg3; - { - try { - Dali_Signal_Sl_void_Sp_Dali_TtsPlayer_State_SS_const_Sc_Dali_TtsPlayer_State_SS_const_SP__Sg__Emit(arg1,arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StateChangedSignalType() { - void * jresult ; - Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *)new Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StateChangedSignalType(void * jarg1) { - Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::TtsPlayer::State const,Dali::TtsPlayer::State const) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/version-check.cpp b/dali-csharp-binder/src/version-check.cpp deleted file mode 100755 index e75f9fcf..00000000 --- a/dali-csharp-binder/src/version-check.cpp +++ /dev/null @@ -1,141 +0,0 @@ -/* - * Copyright (c) 2018 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. - * - */ - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeVersionCheck(int * ver1, int * ver2, int * ver3 ) { - { - try { - *ver1 = Dali::CORE_MAJOR_VERSION; - *ver2 = Dali::CORE_MINOR_VERSION; - *ver3 = Dali::CORE_MICRO_VERSION; - } CALL_CATCH_EXCEPTION(false); - } - return true; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_NUI_InternalAPIVersionCheck(int * version, int * reserved1, int * reserved2 ) -{ - try - { - if(Dali::CORE_MAJOR_VERSION == 1 && Dali::CORE_MINOR_VERSION == 2) - { - //by dali_1.2.85, nui_api_internal_version is set as 400 - if(Dali::CORE_MICRO_VERSION <= 85) - { - *version = 400; - *reserved1 = 0; - *reserved2 = 0; - return true; - } - //from dali_1.2.86, nui_api_internal_version is set as 401 - else if(Dali::CORE_MICRO_VERSION == 86) - { - *version = 401; - *reserved1 = 0; - *reserved2 = 0; - return true; - } - //gotten wrong native wrong version - else - { - *version = Dali::CORE_MAJOR_VERSION; - *reserved1 = Dali::CORE_MINOR_VERSION; - *reserved2 = Dali::CORE_MICRO_VERSION; - return false; - } - } - else if(Dali::CORE_MAJOR_VERSION == 1 && Dali::CORE_MINOR_VERSION == 3) - { - if(Dali::CORE_MICRO_VERSION <= 22) - { - //by dali_1.3.22, nui_api_internal_version is set as 500 - *version = 500; - *reserved1 = 0; - *reserved2 = 0; - return true; - } - else if(Dali::CORE_MICRO_VERSION <= 27) - { - //from dali_1.3.23 to dali 1.3.27, nui_api_internal_version is set as 501 - *version = 501; - *reserved1 = 0; - *reserved2 = 0; - return true; - } - else if(Dali::CORE_MICRO_VERSION <= 33) - { - //from dali_1.3.28, nui_api_internal_version is set as 502 - *version = 502; - *reserved1 = 0; - *reserved2 = 0; - return true; - } - else if(Dali::CORE_MICRO_VERSION <= 40) - { - //from dali_1.3.34, nui_api_internal_version is set as 503 - *version = 503; - *reserved1 = 0; - *reserved2 = 0; - return true; - } - else if(Dali::CORE_MICRO_VERSION <= 47) - { - //from dali_1.3.41, nui_api_internal_version is set as 504 - *version = 504; - *reserved1 = 0; - *reserved2 = 0; - return true; - } - else if(Dali::CORE_MICRO_VERSION <= 99) - { - //from dali_1.3.48, nui_api_internal_version is set as 505 - *version = 505; - *reserved1 = 0; - *reserved2 = 0; - return true; - } - else - { - *version = Dali::CORE_MAJOR_VERSION; - *reserved1 = Dali::CORE_MINOR_VERSION; - *reserved2 = Dali::CORE_MICRO_VERSION; - return false; - } - } - //something wrong - else - { - *version = Dali::CORE_MAJOR_VERSION; - *reserved1 = Dali::CORE_MINOR_VERSION; - *reserved2 = Dali::CORE_MICRO_VERSION; - return false; - } - } - CALL_CATCH_EXCEPTION(false); - return false; -} - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/view-wrapper-impl-wrap.cpp b/dali-csharp-binder/src/view-wrapper-impl-wrap.cpp deleted file mode 100755 index de6935a2..00000000 --- a/dali-csharp-binder/src/view-wrapper-impl-wrap.cpp +++ /dev/null @@ -1,975 +0,0 @@ -/* - * Copyright (c) 2020 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. - * - */ - -// CLASS HEADER -#include "view-wrapper-impl-wrap.h" - -// EXTERNAL INCLUDES -#include -#include -#include - -// INTERNAL INCLUDES -#include "nui-view-accessible.h" - -#ifdef __cplusplus -extern "C" { -#endif - -SwigDirector_ViewWrapperImpl::SwigDirector_ViewWrapperImpl(Dali::Toolkit::Internal::ControlWrapper::CustomControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::ControlWrapper(behaviourFlags) { - swig_init_callbacks(); -} - -SwigDirector_ViewWrapperImpl::~SwigDirector_ViewWrapperImpl() { - -} - - -void SwigDirector_ViewWrapperImpl::OnSceneConnection(int depth) { - swig_callbackOnSceneConnection(depth); - - Dali::Toolkit::Internal::Control::OnSceneConnection(depth); -} - -void SwigDirector_ViewWrapperImpl::OnSceneDisconnection() { - swig_callbackOnSceneDisconnection(); - - Dali::Toolkit::Internal::Control::OnSceneDisconnection(); -} - -void SwigDirector_ViewWrapperImpl::OnChildAdd(Dali::Actor &child) { - void * jchild = (Dali::Actor *) &child; - swig_callbackOnChildAdd(jchild); - - Dali::Toolkit::Internal::Control::OnChildAdd( child ); -} - -void SwigDirector_ViewWrapperImpl::OnChildRemove(Dali::Actor &child) { - void * jchild = (Dali::Actor *) &child; - swig_callbackOnChildRemove(jchild); - - Dali::Toolkit::Internal::Control::OnChildRemove( child ); -} - -void SwigDirector_ViewWrapperImpl::OnPropertySet(Dali::Property::Index index, const Dali::Property::Value& propertyValue) { - int jindex ; - void * jpropertyValue ; - - jindex = index; - jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue); - swig_callbackOnPropertySet(jindex, jpropertyValue); - - Dali::Toolkit::Internal::ControlWrapper::OnPropertySet(index,propertyValue); -} - -void SwigDirector_ViewWrapperImpl::OnSizeSet(Dali::Vector3 const &targetSize) { - swig_callbackOnSizeSet((Dali::Vector3 *) &targetSize); - - Dali::Toolkit::Internal::Control::OnSizeSet(targetSize); -} - -void SwigDirector_ViewWrapperImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) { - swig_callbackOnSizeAnimation(new Dali::Animation(animation), (Dali::Vector3 *) &targetSize); - - Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize); -} - -bool SwigDirector_ViewWrapperImpl::OnKeyEvent(Dali::KeyEvent const &event) { - bool c_result = SwigValueInit< bool >() ; - unsigned int jresult = 0 ; - void * jarg0 = 0 ; - - if (!swig_callbackOnKeyEvent) { - return Dali::Toolkit::Internal::Control::OnKeyEvent(event); - } else { - jarg0 = (Dali::KeyEvent *) &event; - jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0); - c_result = jresult ? true : false; - } - return c_result; -} - -void SwigDirector_ViewWrapperImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) { - void * jsize = 0 ; - void * jcontainer = 0 ; - - jsize = (Dali::Vector2 *) &size; - jcontainer = (Dali::RelayoutContainer *) &container; - swig_callbackOnRelayout(jsize, jcontainer); - - Dali::Toolkit::Internal::Control::OnRelayout(size,container); -} - -void SwigDirector_ViewWrapperImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) { - int jpolicy ; - int jdimension ; - - jpolicy = (int)policy; - jdimension = (int)dimension; - swig_callbackOnSetResizePolicy(jpolicy, jdimension); - - Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension); -} - -Dali::Vector3 SwigDirector_ViewWrapperImpl::GetNaturalSize() { - Dali::Vector3 c_result ; - void * jresult = 0 ; - - if (!swig_callbackGetNaturalSize) { - return Dali::Toolkit::Internal::Control::GetNaturalSize(); - } else { - jresult = (void *) swig_callbackGetNaturalSize(); - if (!jresult) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0); - return c_result; - } - - // Tizen.NUI.ViewWrapperImpl.DirectorGetNaturalSize() is assigned to swig_callbackGetNaturalSize(). - // Tizen.NUI.ViewWrapperImpl.DirectorGetNaturalSize() returns Dali::Vector2. - // Moreover, Dali::Vector3 supports operator '=' with Dali::Vector2. - // Not to cause ASAN heap-buffer-overflow issue here, casting Dali::Vector2 and assigning it to Dali::Vector3 is required. - c_result = *(Dali::Vector2 *)jresult; - } - return c_result; -} - -float SwigDirector_ViewWrapperImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) { - float c_result = SwigValueInit< float >() ; - float jresult = 0 ; - void * jchild = 0 ; - int jdimension ; - - if (!swig_callbackCalculateChildSize) { - return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension); - } else { - jchild = (Dali::Actor *) &child; - jdimension = (int)dimension; - jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension); - c_result = (float)jresult; - } - return c_result; -} - -float SwigDirector_ViewWrapperImpl::GetHeightForWidth(float width) { - float c_result = SwigValueInit< float >() ; - float jresult = 0 ; - float jwidth ; - - if (!swig_callbackGetHeightForWidth) { - return Dali::Toolkit::Internal::Control::GetHeightForWidth(width); - } else { - jwidth = width; - jresult = (float) swig_callbackGetHeightForWidth(jwidth); - c_result = (float)jresult; - } - return c_result; -} - -float SwigDirector_ViewWrapperImpl::GetWidthForHeight(float height) { - float c_result = SwigValueInit< float >() ; - float jresult = 0 ; - float jheight ; - - if (!swig_callbackGetWidthForHeight) { - return Dali::Toolkit::Internal::Control::GetWidthForHeight(height); - } else { - jheight = height; - jresult = (float) swig_callbackGetWidthForHeight(jheight); - c_result = (float)jresult; - } - return c_result; -} - -bool SwigDirector_ViewWrapperImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) { - bool c_result = SwigValueInit< bool >() ; - unsigned int jresult = 0 ; - int jdimension ; - - if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) { - return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension); - } else { - jdimension = (int)dimension; - jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension); - c_result = jresult ? true : false; - } - return c_result; -} - -void SwigDirector_ViewWrapperImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) { - int jdimension ; - - jdimension = (int)dimension; - swig_callbackOnCalculateRelayoutSize(jdimension); - - Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension); -} - -void SwigDirector_ViewWrapperImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) { - float jsize ; - int jdimension ; - - jsize = size; - jdimension = (int)dimension; - swig_callbackOnLayoutNegotiated(jsize, jdimension); - - Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension); -} - -void SwigDirector_ViewWrapperImpl::OnInitialize() { - swig_callbackOnInitialize(); - - Dali::Toolkit::Internal::Control::OnInitialize(); -} - -void SwigDirector_ViewWrapperImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) { - void * jstyleManager ; - int jchange ; - - jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager); - jchange = (int)change; - swig_callbackOnStyleChange(jstyleManager, jchange); - - Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change); -} - -bool SwigDirector_ViewWrapperImpl::OnAccessibilityActivated() { - bool c_result = SwigValueInit< bool >() ; - unsigned int jresult = 0 ; - - if (!swig_callbackOnAccessibilityActivated) { - return Dali::Toolkit::Internal::Control::OnAccessibilityActivated(); - } else { - jresult = (unsigned int) swig_callbackOnAccessibilityActivated(); - c_result = jresult ? true : false; - } - return c_result; -} - -bool SwigDirector_ViewWrapperImpl::OnAccessibilityPan(Dali::PanGesture gesture) { - bool c_result = SwigValueInit< bool >() ; - unsigned int jresult = 0 ; - void * jgesture ; - - if (!swig_callbackOnAccessibilityPan) { - return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture); - } else { - jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture); - jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture); - c_result = jresult ? true : false; - } - return c_result; -} - -bool SwigDirector_ViewWrapperImpl::OnAccessibilityValueChange(bool isIncrease) { - bool c_result = SwigValueInit< bool >(); - unsigned int jresult = 0; - unsigned int jisIncrease; - - if (!swig_callbackOnAccessibilityValueChange) { - return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease); - } else { - jisIncrease = isIncrease; - jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease); - c_result = jresult ? true : false; - } - return c_result; -} - -bool SwigDirector_ViewWrapperImpl::OnAccessibilityZoom() { - bool c_result = SwigValueInit< bool >() ; - unsigned int jresult = 0 ; - - if (!swig_callbackOnAccessibilityZoom) { - return Dali::Toolkit::Internal::Control::OnAccessibilityZoom(); - } else { - jresult = (unsigned int) swig_callbackOnAccessibilityZoom(); - c_result = jresult ? true : false; - } - return c_result; -} - -Dali::Toolkit::DevelControl::ControlAccessible* SwigDirector_ViewWrapperImpl::CreateAccessibleObject() { - return new NUIViewAccessible(Self()); -} - -void SwigDirector_ViewWrapperImpl::OnKeyInputFocusGained() { - swig_callbackOnKeyInputFocusGained(); - - Dali::Toolkit::Internal::Control::OnKeyInputFocusGained(); -} - -void SwigDirector_ViewWrapperImpl::OnKeyInputFocusLost() { - swig_callbackOnKeyInputFocusLost(); - - Dali::Toolkit::Internal::Control::OnKeyInputFocusLost(); -} - -Dali::Actor SwigDirector_ViewWrapperImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) { - Dali::Actor c_result ; - void * jresult = 0 ; - int jdirection ; - unsigned int jloopEnabled ; - - if (!swig_callbackGetNextKeyboardFocusableActor) { - return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled); - } else { - jdirection = (int)direction; - jloopEnabled = loopEnabled; - jresult = (void *) swig_callbackGetNextKeyboardFocusableActor((void*)((Dali::Actor*)¤tFocusedActor), jdirection, jloopEnabled); - if (!jresult) { - // Return empty base handle when NUI returns null. - return c_result; - } - c_result = *(Dali::Actor *)jresult; - } - return c_result; -} - -void SwigDirector_ViewWrapperImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) { - swig_callbackOnKeyboardFocusChangeCommitted((void*)((Dali::Actor*)&commitedFocusableActor)); - - Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor); -} - -bool SwigDirector_ViewWrapperImpl::OnKeyboardEnter() { - bool c_result = SwigValueInit< bool >() ; - unsigned int jresult = 0 ; - - if (!swig_callbackOnKeyboardEnter) { - return Dali::Toolkit::Internal::Control::OnKeyboardEnter(); - } else { - jresult = (unsigned int) swig_callbackOnKeyboardEnter(); - c_result = jresult ? true : false; - } - return c_result; -} - -void SwigDirector_ViewWrapperImpl::OnPinch(Dali::PinchGesture const &pinch) { - void * jpinch = 0 ; - jpinch = (Dali::PinchGesture *) &pinch; - swig_callbackOnPinch(jpinch); - - Dali::Toolkit::Internal::Control::OnPinch(pinch); -} - -void SwigDirector_ViewWrapperImpl::OnPan(Dali::PanGesture const &pan) { - void * jpan = 0 ; - jpan = (Dali::PanGesture *) &pan; - swig_callbackOnPan(jpan); - - Dali::Toolkit::Internal::Control::OnPan(pan); -} - -void SwigDirector_ViewWrapperImpl::OnTap(Dali::TapGesture const &tap) { - void * jtap = 0 ; - jtap = (Dali::TapGesture *) &tap; - swig_callbackOnTap(jtap); - - Dali::Toolkit::Internal::Control::OnTap(tap); -} - -void SwigDirector_ViewWrapperImpl::OnLongPress(Dali::LongPressGesture const &longPress) { - void * jlongPress = 0 ; - - jlongPress = (Dali::LongPressGesture *) &longPress; - swig_callbackOnLongPress(jlongPress); - - Dali::Toolkit::Internal::Control::OnLongPress(longPress); -} - -Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewWrapperImpl::GetControlExtension() { - return Dali::Toolkit::Internal::Control::GetControlExtension(); -} - -void SwigDirector_ViewWrapperImpl::swig_connect_director(SWIG_Callback0_t callbackOnSceneConnection, SWIG_Callback1_t callbackOnSceneDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) { - swig_callbackOnSceneConnection = callbackOnSceneConnection; - swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection; - swig_callbackOnChildAdd = callbackOnChildAdd; - swig_callbackOnChildRemove = callbackOnChildRemove; - swig_callbackOnPropertySet = callbackOnPropertySet; - swig_callbackOnSizeSet = callbackOnSizeSet; - swig_callbackOnSizeAnimation = callbackOnSizeAnimation; - swig_callbackOnKeyEvent = callbackOnKeyEvent; - swig_callbackOnRelayout = callbackOnRelayout; - swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy; - swig_callbackGetNaturalSize = callbackGetNaturalSize; - swig_callbackCalculateChildSize = callbackCalculateChildSize; - swig_callbackGetHeightForWidth = callbackGetHeightForWidth; - swig_callbackGetWidthForHeight = callbackGetWidthForHeight; - swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0; - swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1; - swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize; - swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated; - swig_callbackOnInitialize = callbackOnInitialize; - swig_callbackOnStyleChange = callbackOnStyleChange; - swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated; - swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan; - swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange; - swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom; - swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained; - swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost; - swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor; - swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted; - swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter; - swig_callbackOnPinch = callbackOnPinch; - swig_callbackOnPan = callbackOnPan; - swig_callbackOnTap = callbackOnTap; - swig_callbackOnLongPress = callbackOnLongPress; - swig_callbackSignalConnected = callbackSignalConnected; - swig_callbackSignalDisconnected = callbackSignalDisconnected; -} - -void SwigDirector_ViewWrapperImpl::swig_init_callbacks() { - swig_callbackOnSceneConnection = 0; - swig_callbackOnSceneDisconnection = 0; - swig_callbackOnChildAdd = 0; - swig_callbackOnChildRemove = 0; - swig_callbackOnPropertySet = 0; - swig_callbackOnSizeSet = 0; - swig_callbackOnSizeAnimation = 0; - swig_callbackOnKeyEvent = 0; - swig_callbackOnRelayout = 0; - swig_callbackOnSetResizePolicy = 0; - swig_callbackGetNaturalSize = 0; - swig_callbackCalculateChildSize = 0; - swig_callbackGetHeightForWidth = 0; - swig_callbackGetWidthForHeight = 0; - swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0; - swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0; - swig_callbackOnCalculateRelayoutSize = 0; - swig_callbackOnLayoutNegotiated = 0; - swig_callbackOnInitialize = 0; - swig_callbackOnStyleChange = 0; - swig_callbackOnAccessibilityActivated = 0; - swig_callbackOnAccessibilityPan = 0; - swig_callbackOnAccessibilityValueChange = 0; - swig_callbackOnAccessibilityZoom = 0; - swig_callbackOnKeyInputFocusGained = 0; - swig_callbackOnKeyInputFocusLost = 0; - swig_callbackGetNextKeyboardFocusableActor = 0; - swig_callbackOnKeyboardFocusChangeCommitted = 0; - swig_callbackOnKeyboardEnter = 0; - swig_callbackOnPinch = 0; - swig_callbackOnPan = 0; - swig_callbackOnTap = 0; - swig_callbackOnLongPress = 0; - swig_callbackSignalConnected = 0; - swig_callbackSignalDisconnected = 0; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ViewWrapperImpl_CONTROL_BEHAVIOUR_FLAG_COUNT_get() { - int jresult ; - int result; - - result = (int)Dali::Toolkit::Internal::ControlWrapper::CONTROL_BEHAVIOUR_FLAG_COUNT; - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewWrapperImpl(int jarg1) { - void * jresult ; - Dali::Toolkit::Internal::ControlWrapper::CustomControlBehaviour arg1 ; - Dali::Toolkit::Internal::ControlWrapper *result = 0 ; - - arg1 = (Dali::Toolkit::Internal::ControlWrapper::CustomControlBehaviour)jarg1; - { - try { - result = (Dali::Toolkit::Internal::ControlWrapper *)new SwigDirector_ViewWrapperImpl(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewWrapperImpl_New(char * jarg1, void * jarg2) { - void * jresult ; - std::string arg1 ; - Dali::Toolkit::Internal::ControlWrapper *arg2 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; - Dali::Toolkit::ControlWrapper result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - (&arg1)->assign(jarg1); - arg2 = (Dali::Toolkit::Internal::ControlWrapper *)jarg2; - { - try { - result = Dali::Toolkit::Internal::ControlWrapper::New(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ControlWrapper((const Dali::Toolkit::ControlWrapper &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewWrapperImpl(void * jarg1) { - Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; - - arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; - { - try { - if (arg1) - { - arg1->Unreference(); - } - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewWrapperImpl_director_connect(void *objarg, SwigDirector_ViewWrapperImpl::SWIG_Callback0_t callback0, SwigDirector_ViewWrapperImpl::SWIG_Callback1_t callback1, SwigDirector_ViewWrapperImpl::SWIG_Callback2_t callback2, SwigDirector_ViewWrapperImpl::SWIG_Callback3_t callback3, SwigDirector_ViewWrapperImpl::SWIG_Callback4_t callback4, SwigDirector_ViewWrapperImpl::SWIG_Callback5_t callback5, SwigDirector_ViewWrapperImpl::SWIG_Callback6_t callback6, SwigDirector_ViewWrapperImpl::SWIG_Callback9_t callback9, SwigDirector_ViewWrapperImpl::SWIG_Callback11_t callback11, SwigDirector_ViewWrapperImpl::SWIG_Callback12_t callback12, SwigDirector_ViewWrapperImpl::SWIG_Callback13_t callback13, SwigDirector_ViewWrapperImpl::SWIG_Callback14_t callback14, SwigDirector_ViewWrapperImpl::SWIG_Callback15_t callback15, SwigDirector_ViewWrapperImpl::SWIG_Callback16_t callback16, SwigDirector_ViewWrapperImpl::SWIG_Callback17_t callback17, SwigDirector_ViewWrapperImpl::SWIG_Callback18_t callback18, SwigDirector_ViewWrapperImpl::SWIG_Callback19_t callback19, SwigDirector_ViewWrapperImpl::SWIG_Callback20_t callback20, SwigDirector_ViewWrapperImpl::SWIG_Callback21_t callback21, SwigDirector_ViewWrapperImpl::SWIG_Callback24_t callback24, SwigDirector_ViewWrapperImpl::SWIG_Callback25_t callback25, SwigDirector_ViewWrapperImpl::SWIG_Callback26_t callback26, SwigDirector_ViewWrapperImpl::SWIG_Callback28_t callback28, SwigDirector_ViewWrapperImpl::SWIG_Callback29_t callback29, SwigDirector_ViewWrapperImpl::SWIG_Callback30_t callback30, SwigDirector_ViewWrapperImpl::SWIG_Callback31_t callback31, SwigDirector_ViewWrapperImpl::SWIG_Callback32_t callback32, SwigDirector_ViewWrapperImpl::SWIG_Callback33_t callback33, SwigDirector_ViewWrapperImpl::SWIG_Callback34_t callback34, SwigDirector_ViewWrapperImpl::SWIG_Callback35_t callback35, SwigDirector_ViewWrapperImpl::SWIG_Callback36_t callback36, SwigDirector_ViewWrapperImpl::SWIG_Callback37_t callback37, SwigDirector_ViewWrapperImpl::SWIG_Callback38_t callback38, SwigDirector_ViewWrapperImpl::SWIG_Callback39_t callback39, SwigDirector_ViewWrapperImpl::SWIG_Callback40_t callback40) { - Dali::Toolkit::Internal::ControlWrapper *obj = (Dali::Toolkit::Internal::ControlWrapper *)objarg; - SwigDirector_ViewWrapperImpl *director = dynamic_cast(obj); - if (director) { - director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback9, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback24, callback25, callback26, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40); - } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetControlWrapperImpl__SWIG_0(void * jarg1) { - void * jresult ; - Dali::Toolkit::ControlWrapper *arg1 = 0 ; - Dali::Toolkit::Internal::ControlWrapper *result = 0 ; - - arg1 = (Dali::Toolkit::ControlWrapper *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ControlWrapper & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::Internal::ControlWrapper *) &Dali::Toolkit::GetControlWrapperImpl(*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewWrapper_New(char * jarg1, void * jarg2) { - void * jresult ; - std::string arg1 ; - Dali::Toolkit::Internal::ControlWrapper *arg2 = 0 ; - Dali::Toolkit::ControlWrapper result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - (&arg1)->assign(jarg1); - arg2 = (Dali::Toolkit::Internal::ControlWrapper *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::ControlWrapper & type is null", 0); - return 0; - } - { - try { - result = Dali::Toolkit::ControlWrapper::New(arg1,*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ControlWrapper((const Dali::Toolkit::ControlWrapper &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewWrapper__SWIG_0() { - void * jresult ; - Dali::Toolkit::ControlWrapper *result = 0 ; - - { - try { - result = (Dali::Toolkit::ControlWrapper *)new Dali::Toolkit::ControlWrapper(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewWrapper(void * jarg1) { - Dali::Toolkit::ControlWrapper *arg1 = (Dali::Toolkit::ControlWrapper *) 0 ; - - arg1 = (Dali::Toolkit::ControlWrapper *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewWrapper__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Toolkit::ControlWrapper *arg1 = 0 ; - Dali::Toolkit::ControlWrapper *result = 0 ; - - arg1 = (Dali::Toolkit::ControlWrapper *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ControlWrapper const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::ControlWrapper *)new Dali::Toolkit::ControlWrapper((Dali::Toolkit::ControlWrapper const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewWrapper_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::ControlWrapper *arg1 = (Dali::Toolkit::ControlWrapper *) 0 ; - Dali::Toolkit::ControlWrapper *arg2 = 0 ; - Dali::Toolkit::ControlWrapper *result = 0 ; - - arg1 = (Dali::Toolkit::ControlWrapper *)jarg1; - arg2 = (Dali::Toolkit::ControlWrapper *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ControlWrapper const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::ControlWrapper *) &(arg1)->operator =((Dali::Toolkit::ControlWrapper const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewWrapper_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::Toolkit::ControlWrapper 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::ControlWrapper::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::ControlWrapper((const Dali::Toolkit::ControlWrapper &)result); - return jresult; -} - -SWIGEXPORT Dali::Toolkit::Internal::Control * SWIGSTDCALL CSharp_Dali_ViewWrapperImpl_SWIGUpcast(Dali::Toolkit::Internal::ControlWrapper *jarg1) { - return (Dali::Toolkit::Internal::Control *)jarg1; -} - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ViewWrapper_SWIGUpcast(Dali::Toolkit::ControlWrapper *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_ViewWrapperImpl_RelayoutRequest(void * jarg1) { - Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; - - arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; - { - try { - (arg1)->RelayoutRequest(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_ViewWrapperImpl_GetHeightForWidthBase(void * jarg1, float jarg2) { - float jresult ; - Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; - float arg2 ; - float result; - - arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; - arg2 = (float)jarg2; - { - try { - result = (float)(arg1)->GetHeightForWidthBase(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_ViewWrapperImpl_GetWidthForHeightBase(void * jarg1, float jarg2) { - float jresult ; - Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; - float arg2 ; - float result; - - arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; - arg2 = (float)jarg2; - { - try { - result = (float)(arg1)->GetWidthForHeightBase(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT float SWIGSTDCALL CSharp_ViewWrapperImpl_CalculateChildSizeBase(void * jarg1, void * jarg2, int jarg3) { - float jresult ; - Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; - Dali::Actor *arg2 = 0 ; - Dali::Dimension::Type arg3 ; - float result; - - arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; - arg2 = (Dali::Actor *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0); - return 0; - } - arg3 = (Dali::Dimension::Type)jarg3; - { - try { - result = (float)(arg1)->CalculateChildSizeBase((Dali::Actor const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ViewWrapperImpl_RelayoutDependentOnChildrenBase__SWIG_0(void * jarg1, int jarg2) { - unsigned int jresult ; - Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; - Dali::Dimension::Type arg2 ; - bool result; - - arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; - arg2 = (Dali::Dimension::Type)jarg2; - { - try { - result = (bool)(arg1)->RelayoutDependentOnChildrenBase(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ViewWrapperImpl_RelayoutDependentOnChildrenBase__SWIG_1(void * jarg1) { - unsigned int jresult ; - Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; - bool result; - - arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; - { - try { - result = (bool)(arg1)->RelayoutDependentOnChildrenBase(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_ViewWrapperImpl_RegisterVisual__SWIG_0(void * jarg1, int jarg2, void * jarg3) { - Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; - Dali::Property::Index arg2 ; - Dali::Toolkit::Visual::Base *arg3 = 0 ; - - arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - arg3 = (Dali::Toolkit::Visual::Base *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base & type is null", 0); - return ; - } - { - try { - (arg1)->RegisterVisual(arg2,*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_ViewWrapperImpl_RegisterVisual__SWIG_1(void * jarg1, int jarg2, void * jarg3, unsigned int jarg4) { - Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; - Dali::Property::Index arg2 ; - Dali::Toolkit::Visual::Base *arg3 = 0 ; - bool arg4 ; - - arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - arg3 = (Dali::Toolkit::Visual::Base *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base & type is null", 0); - return ; - } - arg4 = jarg4 ? true : false; - { - try { - (arg1)->RegisterVisual(arg2,*arg3,arg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_ViewWrapperImpl_UnregisterVisual(void * jarg1, int jarg2) { - Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; - Dali::Property::Index arg2 ; - - arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - { - try { - (arg1)->UnregisterVisual(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_ViewWrapperImpl_GetVisual(void * jarg1, int jarg2) { - void * jresult ; - Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; - Dali::Property::Index arg2 ; - Dali::Toolkit::Visual::Base result; - - arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - { - try { - result = ((Dali::Toolkit::Internal::ControlWrapper const *)arg1)->GetVisual(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_ViewWrapperImpl_EnableVisual(void * jarg1, int jarg2, unsigned int jarg3) { - Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; - Dali::Property::Index arg2 ; - bool arg3 ; - - arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - arg3 = jarg3 ? true : false; - { - try { - (arg1)->EnableVisual(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ViewWrapperImpl_IsVisualEnabled(void * jarg1, int jarg2) { - unsigned int jresult ; - Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; - Dali::Property::Index arg2 ; - bool result; - - arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; - arg2 = (Dali::Property::Index)jarg2; - { - try { - result = (bool)((Dali::Toolkit::Internal::ControlWrapper const *)arg1)->IsVisualEnabled(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_ViewWrapperImpl_CreateTransition(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; - Dali::Toolkit::TransitionData *arg2 = 0 ; - Dali::Animation result; - - arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; - arg2 = (Dali::Toolkit::TransitionData *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0); - return 0; - } - { - try { - result = (arg1)->CreateTransition((Dali::Toolkit::TransitionData const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Animation((const Dali::Animation &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_ViewWrapperImpl_EmitKeyInputFocusSignal(void * jarg1, unsigned int jarg2) { - Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; - bool arg2 ; - - arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; - arg2 = jarg2 ? true : false; - { - try { - (arg1)->EmitKeyInputFocusSignal(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewWrapperImpl_ApplyThemeStyle(void * jarg1) { - Dali::Toolkit::Internal::ControlWrapper *arg1 = (Dali::Toolkit::Internal::ControlWrapper *) 0 ; - - arg1 = (Dali::Toolkit::Internal::ControlWrapper *)jarg1; - { - try { - (arg1)->ApplyThemeStyle(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/view-wrapper-impl-wrap.h b/dali-csharp-binder/src/view-wrapper-impl-wrap.h deleted file mode 100644 index 4381d964..00000000 --- a/dali-csharp-binder/src/view-wrapper-impl-wrap.h +++ /dev/null @@ -1,213 +0,0 @@ -#ifndef CSHARP_VIEW_WRAPPER_IMPL_H -#define CSHARP_VIEW_WRAPPER_IMPL_H - -/* - * Copyright (c) 2020 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -class SwigDirector_ViewWrapperImpl : public Dali::Toolkit::Internal::ControlWrapper -{ -public: - - SwigDirector_ViewWrapperImpl(Dali::Toolkit::Internal::ControlWrapper::CustomControlBehaviour behaviourFlags); - virtual ~SwigDirector_ViewWrapperImpl(); - virtual void OnSceneConnection(int depth); - virtual void OnSceneConnectionSwigPublic(int depth) - { - Dali::Toolkit::Internal::Control::OnSceneConnection(depth); - } - virtual void OnSceneDisconnection(); - virtual void OnSceneDisconnectionSwigPublic() - { - Dali::Toolkit::Internal::Control::OnSceneDisconnection(); - } - virtual void OnChildAdd(Dali::Actor &child); - virtual void OnChildAddSwigPublic(Dali::Actor &child) - { - Dali::Toolkit::Internal::Control::OnChildAdd(child); - } - virtual void OnChildRemove(Dali::Actor &child); - virtual void OnChildRemoveSwigPublic(Dali::Actor &child) - { - Dali::Toolkit::Internal::Control::OnChildRemove(child); - } - virtual void OnPropertySet(Dali::Property::Index index, const Dali::Property::Value& propertyValue); - virtual void OnSizeSet(Dali::Vector3 const &targetSize); - virtual void OnSizeSetSwigPublic(Dali::Vector3 const &targetSize) - { - Dali::Toolkit::Internal::Control::OnSizeSet(targetSize); - } - virtual void OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize); - virtual void OnSizeAnimationSwigPublic(Dali::Animation &animation, Dali::Vector3 const &targetSize) - { - Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize); - } - virtual bool OnKeyEvent(Dali::KeyEvent const &event); - virtual bool OnKeyEventSwigPublic(Dali::KeyEvent const &event) - { - return Dali::Toolkit::Internal::Control::OnKeyEvent(event); - } - virtual void OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container); - virtual void OnRelayoutSwigPublic(Dali::Vector2 const &size, Dali::RelayoutContainer &container) - { - Dali::Toolkit::Internal::Control::OnRelayout(size,container); - } - virtual void OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension); - virtual void OnSetResizePolicySwigPublic(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) - { - Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension); - } - virtual Dali::Vector3 GetNaturalSize(); - virtual Dali::Vector3 GetNaturalSizeSwigPublic() - { - return Dali::Toolkit::Internal::Control::GetNaturalSize(); - } - virtual float CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension); - virtual float CalculateChildSizeSwigPublic(Dali::Actor const &child, Dali::Dimension::Type dimension) - { - return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension); - } - virtual float GetHeightForWidth(float width); - virtual float GetHeightForWidthSwigPublic(float width) - { - return Dali::Toolkit::Internal::Control::GetHeightForWidth(width); - } - virtual float GetWidthForHeight(float height); - virtual float GetWidthForHeightSwigPublic(float height) - { - return Dali::Toolkit::Internal::Control::GetWidthForHeight(height); - } - virtual bool RelayoutDependentOnChildren(Dali::Dimension::Type dimension = Dali::Dimension::ALL_DIMENSIONS); - virtual bool RelayoutDependentOnChildrenSwigPublic(Dali::Dimension::Type dimension = Dali::Dimension::ALL_DIMENSIONS) - { - return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension); - } - virtual void OnCalculateRelayoutSize(Dali::Dimension::Type dimension); - virtual void OnCalculateRelayoutSizeSwigPublic(Dali::Dimension::Type dimension) - { - Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension); - } - virtual void OnLayoutNegotiated(float size, Dali::Dimension::Type dimension); - virtual void OnLayoutNegotiatedSwigPublic(float size, Dali::Dimension::Type dimension) - { - Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension); - } - virtual void OnInitialize(); - virtual void OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change); - virtual bool OnAccessibilityActivated(); - virtual bool OnAccessibilityPan(Dali::PanGesture gesture); - virtual bool OnAccessibilityValueChange(bool isIncrease); - virtual bool OnAccessibilityZoom(); - - Dali::Toolkit::DevelControl::ControlAccessible* CreateAccessibleObject() override; - - virtual void OnKeyInputFocusGained(); - virtual void OnKeyInputFocusLost(); - virtual Dali::Actor GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled); - virtual void OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor); - virtual bool OnKeyboardEnter(); - virtual void OnPinch(Dali::PinchGesture const &pinch); - virtual void OnPan(Dali::PanGesture const &pan); - virtual void OnTap(Dali::TapGesture const &tap); - virtual void OnLongPress(Dali::LongPressGesture const &longPress); - virtual Dali::Toolkit::Internal::Control::Extension *GetControlExtension(); - - typedef void (SWIGSTDCALL* SWIG_Callback0_t)(int); - typedef void (SWIGSTDCALL* SWIG_Callback1_t)(); - typedef void (SWIGSTDCALL* SWIG_Callback2_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback3_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback4_t)(int, void *); - typedef void (SWIGSTDCALL* SWIG_Callback5_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback6_t)(void *, void *); - typedef bool (SWIGSTDCALL* SWIG_Callback9_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback11_t)(void *, void *); - typedef void (SWIGSTDCALL* SWIG_Callback12_t)(int, int); - typedef void * (SWIGSTDCALL* SWIG_Callback13_t)(); - typedef float (SWIGSTDCALL* SWIG_Callback14_t)(void *, int); - typedef float (SWIGSTDCALL* SWIG_Callback15_t)(float); - typedef float (SWIGSTDCALL* SWIG_Callback16_t)(float); - typedef bool (SWIGSTDCALL* SWIG_Callback17_t)(int); - typedef bool (SWIGSTDCALL* SWIG_Callback18_t)(); - typedef void (SWIGSTDCALL* SWIG_Callback19_t)(int); - typedef void (SWIGSTDCALL* SWIG_Callback20_t)(float, int); - typedef void (SWIGSTDCALL* SWIG_Callback21_t)(); - typedef void (SWIGSTDCALL* SWIG_Callback22_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback23_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback24_t)(void *, int); - typedef bool (SWIGSTDCALL* SWIG_Callback25_t)(); - typedef bool (SWIGSTDCALL* SWIG_Callback26_t)(void *); - typedef bool (SWIGSTDCALL* SWIG_Callback28_t)(bool); - typedef bool (SWIGSTDCALL* SWIG_Callback29_t)(); - typedef void (SWIGSTDCALL* SWIG_Callback30_t)(); - typedef void (SWIGSTDCALL* SWIG_Callback31_t)(); - typedef void * (SWIGSTDCALL* SWIG_Callback32_t)(void *, int, bool); - typedef void (SWIGSTDCALL* SWIG_Callback33_t)(void *); - typedef bool (SWIGSTDCALL* SWIG_Callback34_t)(); - typedef void (SWIGSTDCALL* SWIG_Callback35_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback36_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback37_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback38_t)(void *); - typedef void (SWIGSTDCALL* SWIG_Callback39_t)(void *, void *); - typedef void (SWIGSTDCALL* SWIG_Callback40_t)(void *, void *); - void swig_connect_director(SWIG_Callback0_t callbackOnSceneConnection, SWIG_Callback1_t callbackOnSceneDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected); - -private: - SWIG_Callback0_t swig_callbackOnSceneConnection; - SWIG_Callback1_t swig_callbackOnSceneDisconnection; - SWIG_Callback2_t swig_callbackOnChildAdd; - SWIG_Callback3_t swig_callbackOnChildRemove; - SWIG_Callback4_t swig_callbackOnPropertySet; - SWIG_Callback5_t swig_callbackOnSizeSet; - SWIG_Callback6_t swig_callbackOnSizeAnimation; - SWIG_Callback9_t swig_callbackOnKeyEvent; - SWIG_Callback11_t swig_callbackOnRelayout; - SWIG_Callback12_t swig_callbackOnSetResizePolicy; - SWIG_Callback13_t swig_callbackGetNaturalSize; - SWIG_Callback14_t swig_callbackCalculateChildSize; - SWIG_Callback15_t swig_callbackGetHeightForWidth; - SWIG_Callback16_t swig_callbackGetWidthForHeight; - SWIG_Callback17_t swig_callbackRelayoutDependentOnChildren__SWIG_0; - SWIG_Callback18_t swig_callbackRelayoutDependentOnChildren__SWIG_1; - SWIG_Callback19_t swig_callbackOnCalculateRelayoutSize; - SWIG_Callback20_t swig_callbackOnLayoutNegotiated; - SWIG_Callback21_t swig_callbackOnInitialize; - SWIG_Callback24_t swig_callbackOnStyleChange; - SWIG_Callback25_t swig_callbackOnAccessibilityActivated; - SWIG_Callback26_t swig_callbackOnAccessibilityPan; - SWIG_Callback28_t swig_callbackOnAccessibilityValueChange; - SWIG_Callback29_t swig_callbackOnAccessibilityZoom; - SWIG_Callback30_t swig_callbackOnKeyInputFocusGained; - SWIG_Callback31_t swig_callbackOnKeyInputFocusLost; - SWIG_Callback32_t swig_callbackGetNextKeyboardFocusableActor; - SWIG_Callback33_t swig_callbackOnKeyboardFocusChangeCommitted; - SWIG_Callback34_t swig_callbackOnKeyboardEnter; - SWIG_Callback35_t swig_callbackOnPinch; - SWIG_Callback36_t swig_callbackOnPan; - SWIG_Callback37_t swig_callbackOnTap; - SWIG_Callback38_t swig_callbackOnLongPress; - SWIG_Callback39_t swig_callbackSignalConnected; - SWIG_Callback40_t swig_callbackSignalDisconnected; - void swig_init_callbacks(); -}; - -#endif /* CSHARP_VIEW_WRAPPER_IMPL_H */ diff --git a/dali-csharp-binder/src/visual-actions-wrap.cpp b/dali-csharp-binder/src/visual-actions-wrap.cpp deleted file mode 100644 index 2f798dfc..00000000 --- a/dali-csharp-binder/src/visual-actions-wrap.cpp +++ /dev/null @@ -1,107 +0,0 @@ -/* - * Copyright (c) 2023 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - - // Visual common action - SWIGEXPORT int SWIGSTDCALL CSharp_Visual_Actions_UPDATE_PROPERTY_get() - { - return (int)Dali::Toolkit::DevelVisual::Action::UPDATE_PROPERTY; - } - - // Image Visual action - SWIGEXPORT int SWIGSTDCALL CSharp_ImageVisual_Actions_RELOAD_get() - { - return (int)Dali::Toolkit::DevelImageVisual::Action::RELOAD; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_ImageVisual_Actions_PLAY_get() - { - return (int)Dali::Toolkit::DevelAnimatedImageVisual::Action::PLAY; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_ImageVisual_Actions_PAUSE_get() - { - return (int)Dali::Toolkit::DevelAnimatedImageVisual::Action::PAUSE; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_ImageVisual_Actions_STOP_get() - { - return (int)Dali::Toolkit::DevelAnimatedImageVisual::Action::STOP; - } - - // Animated Image Visual action - SWIGEXPORT int SWIGSTDCALL CSharp_AnimatedImageVisual_Actions_PLAY_get() - { - return (int)Dali::Toolkit::DevelAnimatedImageVisual::Action::PLAY; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_AnimatedImageVisual_Actions_PAUSE_get() - { - return (int)Dali::Toolkit::DevelAnimatedImageVisual::Action::PAUSE; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_AnimatedImageVisual_Actions_STOP_get() - { - return (int)Dali::Toolkit::DevelAnimatedImageVisual::Action::STOP; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_AnimatedImageVisual_Actions_JUMP_TO_get() - { - return (int)Dali::Toolkit::DevelAnimatedImageVisual::Action::JUMP_TO; - } - - // Animated Vector Image Visual action - SWIGEXPORT int SWIGSTDCALL CSharp_AnimatedVectorImageVisual_Actions_PLAY_get() - { - return (int)Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_AnimatedVectorImageVisual_Actions_PAUSE_get() - { - return (int)Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PAUSE; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_AnimatedVectorImageVisual_Actions_STOP_get() - { - return (int)Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::STOP; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_AnimatedVectorImageVisual_Actions_JUMP_TO_get() - { - return (int)Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::JUMP_TO; - } - - SWIGEXPORT int SWIGSTDCALL CSharp_AnimatedVectorImageVisual_Actions_SET_DYNAMIC_PROPERTY_get() - { - return (int)Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::SET_DYNAMIC_PROPERTY; - } -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/watch-view-wrap.cpp b/dali-csharp-binder/src/watch-view-wrap.cpp deleted file mode 100755 index cc40bce3..00000000 --- a/dali-csharp-binder/src/watch-view-wrap.cpp +++ /dev/null @@ -1,206 +0,0 @@ -/* - * Copyright (c) 2020 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WatchView_SWIGUpcast(Dali::WatchView::WatchView *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchView_New(void * nuiWindow, char * nuiWatchId, char * nuiContentInfo, int nuiWidth, int nuiHeight) { - void * jresult ; - Dali::Window* window = (Dali::Window*)nuiWindow ; - std::string *watchId = 0 ; - std::string *contentInfo = 0 ; - int width ; - int height ; - Dali::WatchView::WatchView result; - - if (!nuiWatchId) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string watchid_str(nuiWatchId); - watchId = &watchid_str; - - if (!nuiContentInfo) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string contenInfo_str(nuiContentInfo); - contentInfo = &contenInfo_str; - width = (int)nuiWidth; - height = (int)nuiHeight; - - { - try { - result = Dali::WatchView::WatchView::New( *window,(std::string const &)*watchId,(std::string const &)*contentInfo,width,height); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::WatchView::WatchView((const Dali::WatchView::WatchView &)result); - - //argout typemap for const std::string& - - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchView_DownCast(void * nuiHandle) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::WatchView::WatchView result; - - argp1 = (Dali::BaseHandle *)nuiHandle; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0); - return 0; - } - arg1 = *argp1; - { - try { - result = Dali::WatchView::WatchView::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::WatchView::WatchView((const Dali::WatchView::WatchView &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchView__SWIG_0() { - void * jresult ; - Dali::WatchView::WatchView *result = 0 ; - - { - try { - result = (Dali::WatchView::WatchView *)new Dali::WatchView::WatchView(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchView__SWIG_1(void * nuiHandle) { - void * jresult ; - Dali::WatchView::WatchView *handle = 0 ; - Dali::WatchView::WatchView *result = 0 ; - - handle = (Dali::WatchView::WatchView *)nuiHandle; - if (!handle) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WatchView::WatchView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::WatchView::WatchView *)new Dali::WatchView::WatchView((Dali::WatchView::WatchView const &)*handle); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchView_Assign(void * nuiWatchview1, void * nuiWatchview2) { - void * jresult ; - Dali::WatchView::WatchView *watchView1 = (Dali::WatchView::WatchView *) 0 ; - Dali::WatchView::WatchView *watchView2 = 0 ; - Dali::WatchView::WatchView *result = 0 ; - - watchView1 = (Dali::WatchView::WatchView *)nuiWatchview1; - watchView2 = (Dali::WatchView::WatchView *)nuiWatchview2; - if (!watchView2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetView::WidgetView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::WatchView::WatchView *) &(watchView1)->operator =((Dali::WatchView::WatchView const &)*watchView2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WatchView(void * nuiWatchview) { - Dali::WatchView::WatchView *watchView = (Dali::WatchView::WatchView *) 0 ; - - watchView = (Dali::WatchView::WatchView *)nuiWatchview; - { - try { - delete watchView; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WatchView_PauseWatch(void * nuiWatchview) { - unsigned int jresult ; - Dali::WatchView::WatchView *watchView = (Dali::WatchView::WatchView *) 0 ; - bool result; - - watchView = (Dali::WatchView::WatchView *)nuiWatchview; - { - try { - result = (bool)(watchView)->PauseWatch(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WatchView_ResumeWatch(void * nuiWatchview) { - unsigned int jresult ; - Dali::WatchView::WatchView *watchView = (Dali::WatchView::WatchView *) 0 ; - bool result; - - watchView = (Dali::WatchView::WatchView *)nuiWatchview; - { - try { - result = (bool)(watchView)->ResumeWatch(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/watch-wrap.cpp b/dali-csharp-binder/src/watch-wrap.cpp deleted file mode 100755 index 40afc503..00000000 --- a/dali-csharp-binder/src/watch-wrap.cpp +++ /dev/null @@ -1,790 +0,0 @@ -/* - * Copyright (c) 2017 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - -// EXTERNAL INCLUDES -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -/* Callback for returning strings to C# without leaking memory */ -typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - - -// keep argcs and argv so they're always available to DALi -int argWatchC = 1; -char **argWatchV = NULL; - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > const *self){ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *self,void (*func)(Dali::Application &,Dali::WatchTime const &)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *self,void (*func)(Dali::Application &,Dali::WatchTime const &)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *self,Dali::Application &arg1,Dali::WatchTime const &arg2){ - self->Emit( arg1, arg2 ); -} - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Application &,bool) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &,bool) > const *self){ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Application &,bool) > *self,void (*func)(Dali::Application &,bool)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &,bool) > *self,void (*func)(Dali::Application &,bool)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Application &,bool) > *self,Dali::Application &arg1,bool arg2){ - self->Emit( arg1, arg2 ); -} - -#ifdef __cplusplus -extern "C" { -#endif - -/*watch binding*/ - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchTime() { - void * jresult ; - Dali::WatchTime *result = 0 ; - - { - try { - result = (Dali::WatchTime *)new Dali::WatchTime(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WatchTime(void * jarg1) { - Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; - - arg1 = (Dali::WatchTime *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetHour(void * jarg1) { - int jresult ; - Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; - int result; - - arg1 = (Dali::WatchTime *)jarg1; - { - try { - result = (int)((Dali::WatchTime const *)arg1)->GetHour(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetHour24(void * jarg1) { - int jresult ; - Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; - int result; - - arg1 = (Dali::WatchTime *)jarg1; - { - try { - result = (int)((Dali::WatchTime const *)arg1)->GetHour24(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetMinute(void * jarg1) { - int jresult ; - Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; - int result; - - arg1 = (Dali::WatchTime *)jarg1; - { - try { - result = (int)((Dali::WatchTime const *)arg1)->GetMinute(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetSecond(void * jarg1) { - int jresult ; - Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; - int result; - - arg1 = (Dali::WatchTime *)jarg1; - { - try { - result = (int)((Dali::WatchTime const *)arg1)->GetSecond(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetMillisecond(void * jarg1) { - int jresult ; - Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; - int result; - - arg1 = (Dali::WatchTime *)jarg1; - { - try { - result = (int)((Dali::WatchTime const *)arg1)->GetMillisecond(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetYear(void * jarg1) { - int jresult ; - Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; - int result; - - arg1 = (Dali::WatchTime *)jarg1; - { - try { - result = (int)((Dali::WatchTime const *)arg1)->GetYear(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetMonth(void * jarg1) { - int jresult ; - Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; - int result; - - arg1 = (Dali::WatchTime *)jarg1; - { - try { - result = (int)((Dali::WatchTime const *)arg1)->GetMonth(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetDay(void * jarg1) { - int jresult ; - Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; - int result; - - arg1 = (Dali::WatchTime *)jarg1; - { - try { - result = (int)((Dali::WatchTime const *)arg1)->GetDay(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WatchTime_GetDayOfWeek(void * jarg1) { - int jresult ; - Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; - int result; - - arg1 = (Dali::WatchTime *)jarg1; - { - try { - result = (int)((Dali::WatchTime const *)arg1)->GetDayOfWeek(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchTime_GetUtcTime(void * jarg1) { - void * jresult ; - Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; - tm result; - - arg1 = (Dali::WatchTime *)jarg1; - { - try { - result = ((Dali::WatchTime const *)arg1)->GetUtcTime(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new tm((const tm &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchTime_GetUtcTimeStamp(void * jarg1) { - void * jresult ; - Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; - time_t result; - - arg1 = (Dali::WatchTime *)jarg1; - { - try { - result = ((Dali::WatchTime const *)arg1)->GetUtcTimeStamp(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new time_t((const time_t &)result); - return jresult; -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_WatchTime_GetTimeZone(void * jarg1) { - char * jresult ; - Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; - char *result = 0 ; - - arg1 = (Dali::WatchTime *)jarg1; - { - try { - result = (char *)((Dali::WatchTime const *)arg1)->GetTimeZone(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = SWIG_csharp_string_callback((const char *)result); - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WatchTime_GetDaylightSavingTimeStatus(void * jarg1) { - unsigned int jresult ; - Dali::WatchTime *arg1 = (Dali::WatchTime *) 0 ; - bool result; - - arg1 = (Dali::WatchTime *)jarg1; - { - try { - result = (bool)((Dali::WatchTime const *)arg1)->GetDaylightSavingTimeStatus(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_New__SWIG_0() { - void * jresult ; - Dali::WatchApplication result; - - { - try { - result = Dali::WatchApplication::New(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::WatchApplication((const Dali::WatchApplication &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_New__SWIG_1(int jarg1, char * jarg2) { - void * jresult ; - int *arg1 = (int *) 0 ; - char ***arg2 ; - Dali::WatchApplication result; - { - int index = 0; - int length = 0; - char *retPtr; - char *nextPtr; - argWatchC = jarg1; - argWatchV = new char*[jarg1 + 1]; - - retPtr = strtok_r(jarg2, " ", &nextPtr); - if( retPtr ) - { - length = strlen(retPtr); - } - argWatchV[index] = new char[length + 1]; - if( retPtr ) - { - strncpy(argWatchV[index], retPtr, length); - } - argWatchV[index][length] = '\0'; - index++; - - while( index < jarg1 ) - { - length = 0; - retPtr = strtok_r(NULL, " ", &nextPtr); - if( retPtr ) - { - length = strlen(retPtr); - } - argWatchV[index] = new char[length + 1]; - if( retPtr ) - { - strncpy(argWatchV[index], retPtr, length); - } - argWatchV[index][length] = '\0'; - index++; - } - } - - argWatchV[jarg1] = NULL; - - arg1 = &argWatchC; - arg2 = &argWatchV; - { - try { - result = Dali::WatchApplication::New(arg1,arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::WatchApplication((const Dali::WatchApplication &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_New__SWIG_2(int jarg1, char * jarg2, char * jarg3) { - void * jresult ; - int *arg1 = (int *) 0 ; - char ***arg2 ; - std::string *arg3 = 0 ; - Dali::WatchApplication result; - { - int index = 0; - int length = 0; - char *retPtr; - char *nextPtr; - argWatchC = jarg1; - argWatchV = new char*[jarg1 + 1]; - - retPtr = strtok_r(jarg2, " ", &nextPtr); - if( retPtr ) - { - length = strlen(retPtr); - } - argWatchV[index] = new char[length + 1]; - if( retPtr ) - { - strncpy(argWatchV[index], retPtr, length); - } - argWatchV[index][length] = '\0'; - index++; - - while( index < jarg1 ) - { - length = 0; - retPtr = strtok_r(NULL, " ", &nextPtr); - if( retPtr ) - { - length = strlen(retPtr); - } - argWatchV[index] = new char[length + 1]; - if( retPtr ) - { - strncpy(argWatchV[index], retPtr, length); - } - argWatchV[index][length] = '\0'; - index++; - } - } - - argWatchV[jarg1] = NULL; - - arg1 = &argWatchC; - arg2 = &argWatchV; - if (!jarg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg3_str(jarg3); - arg3 = &arg3_str; - { - try { - result = Dali::WatchApplication::New(arg1,arg2,(std::string const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::WatchApplication((const Dali::WatchApplication &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchApplication__SWIG_0() { - void * jresult ; - Dali::WatchApplication *result = 0 ; - - { - try { - result = (Dali::WatchApplication *)new Dali::WatchApplication(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchApplication__SWIG_1(void * jarg1) { - void * jresult ; - Dali::WatchApplication *arg1 = 0 ; - Dali::WatchApplication *result = 0 ; - - arg1 = (Dali::WatchApplication *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WatchApplication const & type is null", 0); - return 0; - } - { - try { - result = (Dali::WatchApplication *)new Dali::WatchApplication((Dali::WatchApplication const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::WatchApplication *arg1 = (Dali::WatchApplication *) 0 ; - Dali::WatchApplication *arg2 = 0 ; - Dali::WatchApplication *result = 0 ; - - arg1 = (Dali::WatchApplication *)jarg1; - arg2 = (Dali::WatchApplication *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WatchApplication const & type is null", 0); - return 0; - } - { - try { - result = (Dali::WatchApplication *) &(arg1)->operator =((Dali::WatchApplication const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WatchApplication(void * jarg1) { - Dali::WatchApplication *arg1 = (Dali::WatchApplication *) 0 ; - - arg1 = (Dali::WatchApplication *)jarg1; - { - try { - delete arg1; - if( argWatchV ) - { - //free string data - for (int i=0; iTimeTickSignal(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_AmbientTickSignal(void * jarg1) { - void * jresult ; - Dali::WatchApplication *arg1 = (Dali::WatchApplication *) 0 ; - Dali::WatchApplication::WatchTimeSignal *result = 0 ; - - arg1 = (Dali::WatchApplication *)jarg1; - { - try { - result = (Dali::WatchApplication::WatchTimeSignal *) &(arg1)->AmbientTickSignal(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchApplication_AmbientChangedSignal(void * jarg1) { - void * jresult ; - Dali::WatchApplication *arg1 = (Dali::WatchApplication *) 0 ; - Dali::WatchApplication::WatchBoolSignal *result = 0 ; - - arg1 = (Dali::WatchApplication *)jarg1; - { - try { - result = (Dali::WatchApplication::WatchBoolSignal *) &(arg1)->AmbientChangedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WatchTimeSignal_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WatchTimeSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchTimeSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ; - void (*arg2)(Dali::Application &,Dali::WatchTime const &) = (void (*)(Dali::Application &,Dali::WatchTime const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1; - arg2 = (void (*)(Dali::Application &,Dali::WatchTime const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchTimeSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ; - void (*arg2)(Dali::Application &,Dali::WatchTime const &) = (void (*)(Dali::Application &,Dali::WatchTime const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1; - arg2 = (void (*)(Dali::Application &,Dali::WatchTime const &))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchTimeSignal_Emit(void * jarg1, void * jarg2, void * jarg3) { - Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ; - Dali::Application *arg2 = 0 ; - Dali::WatchTime *arg3 = 0 ; - - arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1; - arg2 = (Dali::Application *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0); - return ; - } - arg3 = (Dali::WatchTime *)jarg3; - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WatchTime const & type is null", 0); - return ; - } - { - try { - Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_Dali_WatchTime_SS_const_SA__SP__Sg__Emit(arg1,*arg2,(Dali::WatchTime const &)*arg3); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchTimeSignal() { - void * jresult ; - Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)new Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) >(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WatchTimeSignal(void * jarg1) { - Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Application &,Dali::WatchTime const &) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WatchBoolSignal_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Application &,bool) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WatchBoolSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,bool) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchBoolSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ; - void (*arg2)(Dali::Application &,bool) = (void (*)(Dali::Application &,bool)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1; - arg2 = (void (*)(Dali::Application &,bool))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchBoolSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ; - void (*arg2)(Dali::Application &,bool) = (void (*)(Dali::Application &,bool)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1; - arg2 = (void (*)(Dali::Application &,bool))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WatchBoolSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) { - Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ; - Dali::Application *arg2 = 0 ; - bool arg3 ; - - arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1; - arg2 = (Dali::Application *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0); - return ; - } - arg3 = jarg3 ? true : false; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_bool_SP__Sg__Emit(arg1,*arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchBoolSignal() { - void * jresult ; - Dali::Signal< void (Dali::Application &,bool) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Application &,bool) > *)new Dali::Signal< void (Dali::Application &,bool) >(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WatchBoolSignal(void * jarg1) { - Dali::Signal< void (Dali::Application &,bool) > *arg1 = (Dali::Signal< void (Dali::Application &,bool) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Application &,bool) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/web-view-wrap.cpp b/dali-csharp-binder/src/web-view-wrap.cpp deleted file mode 100755 index 1e01d59f..00000000 --- a/dali-csharp-binder/src/web-view-wrap.cpp +++ /dev/null @@ -1,3721 +0,0 @@ -/* - * Copyright (c) 2022 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -/* Callback for returning strings to C# without leaking memory */ -using SWIG_CSharpStringHelperCallback = char* (SWIGSTDCALL*)(const char*); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - -#ifdef __cplusplus -extern "C" { -#endif - -//----------------------------------WebView--------------------------------------------------- -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() { - void * jresult; - Dali::Toolkit::WebView result; - - { - try { - result = Dali::Toolkit::WebView::New(); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView&)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) { - void * jresult; - Dali::Toolkit::WebView result; - - std::string *arg1; - std::string *arg2; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0); - return 0; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); - return 0; - } - - std::string jarg1_str = std::string(jarg1); - std::string jarg2_str = std::string(jarg2); - - arg1 = &jarg1_str; - arg2 = &jarg2_str; - - { - try { - result = Dali::Toolkit::WebView::New((std::string const &)*arg1, (std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView&)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_3(uint32_t jarg1, char ** jarg2) { - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0); - return 0; - } - - Dali::Toolkit::WebView result; - { - try { - result = Dali::Toolkit::WebView::New(jarg1, jarg2); - } CALL_CATCH_EXCEPTION(0); - } - void * jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_GetContext() { - void * jresult; - Dali::WebEngineContext *result = 0; - - { - try { - result = Dali::Toolkit::WebView::GetContext(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_GetCookieManager() { - void * jresult; - Dali::WebEngineCookieManager *result = 0; - - { - try { - result = Dali::Toolkit::WebView::GetCookieManager(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) { - void * jresult; - Dali::Toolkit::WebView* arg1 = 0; - Dali::Toolkit::WebView* result = 0; - - arg1 = (Dali::Toolkit::WebView*)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::WebView*)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; - arg1 = (Dali::Toolkit::WebView*)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) { - void * jresult; - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; - Dali::Toolkit::WebView* arg2 = 0; - Dali::Toolkit::WebView* result = 0; - - arg1 = (Dali::Toolkit::WebView*)jarg1; - arg2 = (Dali::Toolkit::WebView*)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Toolkit::WebView*)&(arg1)->operator=((Dali::Toolkit::WebView const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) { - void * jresult; - Dali::BaseHandle arg1; - Dali::BaseHandle* argp1; - Dali::Toolkit::WebView 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::WebView::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView&)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_GetBackForwardList(void * jarg1) { - void * jresult; - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; - Dali::Toolkit::WebBackForwardList *result = 0; - - arg1 = (Dali::Toolkit::WebView*)jarg1; - - { - try { - result = arg1->GetBackForwardList(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_GetSettings(void * jarg1) { - void * jresult; - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; - Dali::Toolkit::WebSettings *result = 0; - - arg1 = (Dali::Toolkit::WebView*)jarg1; - - { - try { - result = arg1->GetSettings(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() { - return (int)Dali::Toolkit::WebView::Property::URL; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_SCROLL_POSITION_get() { - return (int)Dali::Toolkit::WebView::Property::SCROLL_POSITION; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_SCROLL_SIZE_get() { - return (int)Dali::Toolkit::WebView::Property::SCROLL_SIZE; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CONTENT_SIZE_get() { - return (int)Dali::Toolkit::WebView::Property::CONTENT_SIZE; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_TITLE_get() { - return (int)Dali::Toolkit::WebView::Property::TITLE; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_VIDEO_HOLE_ENABLED_get() { - return (int)Dali::Toolkit::WebView::Property::VIDEO_HOLE_ENABLED; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_MOUSE_EVENTS_ENABLED_get() { - return (int) Dali::Toolkit::WebView::Property::MOUSE_EVENTS_ENABLED; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_KEY_EVENTS_ENABLED_get() { - return (int) Dali::Toolkit::WebView::Property::KEY_EVENTS_ENABLED; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DOCUMENT_BACKGROUND_COLOR_get() { - return (int)Dali::Toolkit::WebView::Property::DOCUMENT_BACKGROUND_COLOR; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_TILES_CLEARED_WHEN_HIDDEN_get() { - return (int)Dali::Toolkit::WebView::Property::TILES_CLEARED_WHEN_HIDDEN; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_TILE_COVER_AREA_MULTIPLIER_get() { - return (int)Dali::Toolkit::WebView::Property::TILE_COVER_AREA_MULTIPLIER; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CURSOR_ENABLED_BY_CLIENT_get() { - return (int)Dali::Toolkit::WebView::Property::CURSOR_ENABLED_BY_CLIENT; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_SELECTED_TEXT_get() { - return (int)Dali::Toolkit::WebView::Property::SELECTED_TEXT; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_PAGE_ZOOM_FACTOR_get() { - return (int)Dali::Toolkit::WebView::Property::PAGE_ZOOM_FACTOR; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_TEXT_ZOOM_FACTOR_get() { - return (int)Dali::Toolkit::WebView::Property::TEXT_ZOOM_FACTOR; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_PROGRESS_PERCENTAGE_get() { - return (int)Dali::Toolkit::WebView::Property::LOAD_PROGRESS_PERCENTAGE; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() { - return (int)Dali::Toolkit::WebView::Property::USER_AGENT; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; - std::string *arg2; - - arg1 = (Dali::Toolkit::WebView*)jarg1; - - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return; - } - - std::string jarg2str = std::string(jarg2); - arg2 = &jarg2str; - { - try { - (arg1)->LoadUrl((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHtmlString(void * jarg1, char * jarg2) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; - std::string *arg2; - - arg1 = (Dali::Toolkit::WebView*)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return; - } - std::string jarg2str = std::string(jarg2); - arg2 = &jarg2str; - { - try { - (arg1)->LoadHtmlString((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_LoadHtmlStringOverrideCurrentEntry(void * jarg1, const char *jarg2, const char *jarg3, const char *jarg4) { - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return false; - } - - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - std::string jarg2str = std::string(jarg2); - std::string jarg3str = jarg3 ? std::string(jarg3) : std::string(); - std::string jarg4str = jarg4 ? std::string(jarg4) : std::string(); - bool result = false; - { - try { - result = (arg1)->LoadHtmlStringOverrideCurrentEntry(jarg2str, jarg3str, jarg4str); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_LoadContents(void * jarg1, const int8_t *jarg2, uint32_t jarg3, const char *jarg4, const char *jarg5, const char *jarg6) { - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return false; - } - - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - std::string jarg4str = jarg4 ? std::string(jarg4) : std::string(); - std::string jarg5str = jarg5 ? std::string(jarg5) : std::string(); - std::string jarg6str = jarg6 ? std::string(jarg6) : std::string(); - bool result = false; - { - try { - result = (arg1)->LoadContents(jarg2, jarg3, jarg4str, jarg5str, jarg6str); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT const void * SWIGSTDCALL CSharp_Dali_WebView_GetFavicon(void * jarg1) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)jarg1; - Dali::Toolkit::ImageView* result = 0; - { - try { - Dali::Toolkit::ImageView favicon = (arg1)->GetFavicon(); - if (favicon) - { - result = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)favicon); - } - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; - - arg1 = (Dali::Toolkit::WebView*)jarg1; - { - try { - (arg1)->Reload(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_ReloadWithoutCache(void * jarg1) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - bool result = false; - { - try { - result = (arg1)->ReloadWithoutCache(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; - - arg1 = (Dali::Toolkit::WebView*)jarg1; - { - try { - (arg1)->StopLoading(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; - - arg1 = (Dali::Toolkit::WebView*)jarg1; - { - try { - (arg1)->Suspend(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; - - arg1 = (Dali::Toolkit::WebView*)jarg1; - { - try { - (arg1)->Resume(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_SuspendNetworkLoading(void * jarg1) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - { - try { - (arg1)->SuspendNetworkLoading(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ResumeNetworkLoading(void * jarg1) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - { - try { - (arg1)->ResumeNetworkLoading(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_AddCustomHeader(void * jarg1, const char *jarg2, const char *jarg3) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - std::string jarg2str = std::string(jarg2); - std::string jarg3str = std::string(jarg3); - bool result = false; - { - try { - result = (arg1)->AddCustomHeader(jarg2str, jarg3str); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_RemoveCustomHeader(void * jarg1, const char *jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - std::string jarg2str = std::string(jarg2); - bool result = false; - { - try { - result = (arg1)->RemoveCustomHeader(jarg2str); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebView_StartInspectorServer(void * jarg1, uint32_t jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - uint32_t result = 0; - { - try { - result = (arg1)->StartInspectorServer(jarg2); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_StopInspectorServer(void * jarg1) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - bool result = false; - { - try { - result = (arg1)->StopInspectorServer(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ScrollBy(void * jarg1, int32_t jarg2, int32_t jarg3) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; - arg1 = (Dali::Toolkit::WebView*)jarg1; - { - try { - (arg1)->ScrollBy(jarg2, jarg3); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_ScrollEdgeBy(void * jarg1, int32_t jarg2, int32_t jarg3) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - bool result = false; - { - try { - result = (arg1)->ScrollEdgeBy(jarg2, jarg3); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; - - arg1 = (Dali::Toolkit::WebView*)jarg1; - { - try { - (arg1)->GoBack(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; - - arg1 = (Dali::Toolkit::WebView*)jarg1; - { - try { - (arg1)->GoForward(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; - bool ret; - - arg1 = (Dali::Toolkit::WebView*)jarg1; - { - try { - ret = (arg1)->CanGoBack(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; - bool ret; - - arg1 = (Dali::Toolkit::WebView*)jarg1; - { - try { - ret = (arg1)->CanGoForward(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void * jarg3) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; - std::string *arg2; - - arg1 = (Dali::Toolkit::WebView*)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return; - } - std::string jarg2_str = std::string(jarg2); - arg2 = &jarg2_str; - - { - try { - if (jarg3) { - void (*handler)(char *) = (void (*)(char *))jarg3; - (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string &result) { - handler(SWIG_csharp_string_callback(result.c_str())); - }); - } - else { - (arg1)->EvaluateJavaScript((std::string const &)*arg2); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void * jarg1, char * jarg2, void * jarg3) { - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return; - } - - Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1; - std::string exposedObjectName = jarg2; - void (*handler)(char*) = (void (*)(char*))jarg3; - - { - try { - webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string &message) { - handler(SWIG_csharp_string_callback(message.c_str())); - }); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterJavaScriptAlertCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1; - bool (*handler)(char*) = (bool (*)(char*))jarg2; - { - try { - if (handler) - { - webview->RegisterJavaScriptAlertCallback([handler](const std::string &message) -> bool { - return handler(SWIG_csharp_string_callback(message.c_str())); - }); - } - else - { - webview->RegisterJavaScriptAlertCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_JavaScriptAlertReply(void * jarg1) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)jarg1; - { - try { - (arg1)->JavaScriptAlertReply(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterJavaScriptConfirmCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1; - bool (*handler)(char*) = (bool (*)(char*))jarg2; - - { - try { - if (handler) - { - webview->RegisterJavaScriptConfirmCallback([handler](const std::string &message) -> bool { - return handler(SWIG_csharp_string_callback(message.c_str())); - }); - } - else - { - webview->RegisterJavaScriptConfirmCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_JavaScriptConfirmReply(void * jarg1, bool jarg2) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)jarg1; - { - try { - (arg1)->JavaScriptConfirmReply(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterJavaScriptPromptCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1; - bool (*handler)(char *, char*) = (bool (*)(char *, char*))jarg2; - - { - try { - if (handler) - { - webview->RegisterJavaScriptPromptCallback([handler](const std::string &message1, - const std::string &message2) -> bool { - return handler(SWIG_csharp_string_callback(message1.c_str()), - SWIG_csharp_string_callback(message2.c_str())); - }); - } - else - { - webview->RegisterJavaScriptPromptCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_JavaScriptPromptReply(void * jarg1, char * jarg2) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)jarg1; - std::string jarg2str = std::string(jarg2); - { - try { - (arg1)->JavaScriptPromptReply(jarg2str); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WebView_CreateHitTest(void * jarg1, int32_t jarg2, int32_t jarg3, int jarg4) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)jarg1; - Dali::WebEngineHitTest* result = 0; - { - try { - std::unique_ptr hitTest = (arg1)->CreateHitTest(jarg2, jarg3, (Dali::WebEngineHitTest::HitTestMode)jarg4); - result = hitTest.release(); - } CALL_CATCH_EXCEPTION(0); - } - return (void *)result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CreateHitTestAsynchronously(void * jarg1, int32_t jarg2, int32_t jarg3, int jarg4, void * jarg5) { - Dali::Toolkit::WebView *webview = (Dali::Toolkit::WebView *)jarg1; - bool (*handler)(Dali::WebEngineHitTest*) = (bool (*)(Dali::WebEngineHitTest*))jarg5; - bool result = false; - { - try { - result = webview->CreateHitTestAsynchronously(jarg2, jarg3, (Dali::WebEngineHitTest::HitTestMode)jarg4, - [handler](std::unique_ptr hitTest) -> bool { - return handler(hitTest.release()); - }); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)0; - - arg1 = (Dali::Toolkit::WebView*)jarg1; - { - try { - (arg1)->ClearHistory(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearAllTilesResources(void * jarg1) { - Dali::Toolkit::WebView* arg1 = (Dali::Toolkit::WebView*)jarg1; - { - try { - (arg1)->ClearAllTilesResources(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_SetScaleFactor(void * jarg1, float jarg2, void * jarg3) { - if (!jarg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 is null", 0); - return; - } - - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - Dali::Vector2 *arg3 = (Dali::Vector2 *)jarg3; - { - try { - (arg1)->SetScaleFactor(jarg2, *arg3); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WebView_GetScaleFactor(void * jarg1) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - float result = 0.0f; - { - try { - result = (arg1)->GetScaleFactor(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ActivateAccessibility(void * jarg1, bool jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - { - try { - (arg1)->ActivateAccessibility(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_HighlightText(void * jarg1, const char *jarg2, int jarg3, uint32_t jarg4) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - std::string jarg2str = std::string(jarg2); - bool result = false; - { - try { - result = (arg1)->HighlightText( - jarg2str, (Dali::WebEnginePlugin::FindOption)jarg3, jarg4); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddDynamicCertificatePath(void * jarg1, const char *jarg2, const char *jarg3) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - std::string jarg2str = std::string(jarg2); - std::string jarg3str = std::string(jarg3); - { - try { - (arg1)->AddDynamicCertificatePath(jarg2str, jarg3str); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WebView_GetScreenshot(void * jarg1, void * jarg2, float jarg3) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - Dali::Rect *arg = (Dali::Rect *)jarg2; - Dali::Toolkit::ImageView* result = 0; - { - try { - Dali::Toolkit::ImageView screenshot = (arg1)->GetScreenshot(*arg, jarg3); - if (screenshot) - { - result = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)screenshot); - } - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -using SWIG_CallbackWebViewScreenshotCaptured = void(SWIGSTDCALL *)(Dali::Toolkit::ImageView *); -SWIG_CallbackWebViewScreenshotCaptured swig_callbackOnWebViewScreenshotCaptured; - -void OnWebViewScreenshotCapturedCallback(Dali::Toolkit::ImageView imageView) { - if (!imageView) - return; - - Dali::Toolkit::ImageView* pImageView = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)imageView); - swig_callbackOnWebViewScreenshotCaptured(pImageView); -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_GetScreenshotAsynchronously(void * jarg1, void * jarg2, float jarg3, void * jarg4) { - swig_callbackOnWebViewScreenshotCaptured = (SWIG_CallbackWebViewScreenshotCaptured)jarg4; - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - Dali::Rect *arg2 = (Dali::Rect *)jarg2; - Dali::Toolkit::WebView::WebViewScreenshotCapturedCallback callback = OnWebViewScreenshotCapturedCallback; - bool result; - { - try { - result = (arg1)->GetScreenshotAsynchronously(*arg2, jarg3, callback); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CheckVideoPlayingAsynchronously(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - void (*handler)(bool) = (void (*)(bool))jarg2; - bool result; - { - try { - result = (arg1)->CheckVideoPlayingAsynchronously([handler](bool isPlaying) { handler(isPlaying); }); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterGeolocationPermissionCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - bool (*handler)(char *, char *) = (bool (*)(char *, char *))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterGeolocationPermissionCallback([handler](const std::string &host, const std::string &protocol) -> bool { - return handler(SWIG_csharp_string_callback(host.c_str()), - SWIG_csharp_string_callback(protocol.c_str())); - }); - } - else - { - (arg1)->RegisterGeolocationPermissionCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_SetTtsFocus(void* jarg1, bool jarg2) { - Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*)jarg1; - try { - webview->SetTtsFocus(jarg2); - } CALL_CATCH_EXCEPTION(); -} - -SWIGEXPORT Dali::Toolkit::Control *SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView* jarg1) { - return (Dali::Toolkit::Control*)jarg1; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterPageLoadStartedCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - void (*handler)(char*) = (void (*)(char*))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterPageLoadStartedCallback([handler](const std::string& url) { - handler(SWIG_csharp_string_callback(url.c_str())); - }); - } - else - { - (arg1)->RegisterPageLoadStartedCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterPageLoadInProgressCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - void (*handler)(char*) = (void (*)(char*))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterPageLoadInProgressCallback([handler](const std::string& url) { - handler(SWIG_csharp_string_callback(url.c_str())); - }); - } - else - { - (arg1)->RegisterPageLoadInProgressCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterPageLoadFinishedCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - void (*handler)(char*) = (void (*)(char*))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterPageLoadFinishedCallback([handler](const std::string& url) { - handler(SWIG_csharp_string_callback(url.c_str())); - }); - } - else - { - (arg1)->RegisterPageLoadFinishedCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterPageLoadErrorCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - void (*handler)(Dali::WebEngineLoadError*) = (void (*)(Dali::WebEngineLoadError*))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterPageLoadErrorCallback([handler](std::unique_ptr error) { - handler(error.release()); - }); - } - else - { - (arg1)->RegisterPageLoadErrorCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterScrollEdgeReachedCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - void (*handler)(int) = (void (*)(int))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterScrollEdgeReachedCallback([handler](Dali::WebEnginePlugin::ScrollEdge edge) { - handler((int)edge); - }); - } - else - { - (arg1)->RegisterScrollEdgeReachedCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterUrlChangedCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - void (*handler)(char*) = (void (*)(char*))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterUrlChangedCallback([handler](const std::string& url) { - handler(SWIG_csharp_string_callback(url.c_str())); - }); - } - else - { - (arg1)->RegisterUrlChangedCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterFormRepostDecidedCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - void (*handler)(Dali::WebEngineFormRepostDecision*) = (void (*)(Dali::WebEngineFormRepostDecision*))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterFormRepostDecidedCallback([handler](std::unique_ptr decision) { - handler(decision.release()); - }); - } - else - { - (arg1)->RegisterFormRepostDecidedCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterFrameRenderedCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - void (*handler)(void) = (void (*)(void))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterFrameRenderedCallback([handler](void) { - handler(); - }); - } - else - { - (arg1)->RegisterFrameRenderedCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterConsoleMessageReceivedCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - void (*handler)(Dali::WebEngineConsoleMessage*) = (void (*)(Dali::WebEngineConsoleMessage*))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterConsoleMessageReceivedCallback([handler](std::unique_ptr message) { - handler(message.release()); - }); - } - else - { - (arg1)->RegisterConsoleMessageReceivedCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterResponsePolicyDecidedCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - void (*handler)(Dali::WebEnginePolicyDecision*) = (void (*)(Dali::WebEnginePolicyDecision*))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterResponsePolicyDecidedCallback([handler](std::unique_ptr decision) { - handler(decision.release()); - }); - } - else - { - (arg1)->RegisterResponsePolicyDecidedCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterNavigationPolicyDecidedCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - void (*handler)(Dali::WebEnginePolicyDecision*) = (void (*)(Dali::WebEnginePolicyDecision*))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterNavigationPolicyDecidedCallback([handler](std::unique_ptr decision) { - handler(decision.release()); - }); - } - else - { - (arg1)->RegisterNavigationPolicyDecidedCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterNewWindowCreatedCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - void (*handler)(Dali::Toolkit::WebView*&) = (void (*)(Dali::Toolkit::WebView*&))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterNewWindowCreatedCallback([handler](Dali::WebEnginePlugin*& plugin) { - Dali::Toolkit::WebView* outView = nullptr; - handler(outView); - if (outView != nullptr) - { - plugin = outView->GetPlugin(); - } - }); - } - else - { - (arg1)->RegisterNewWindowCreatedCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterCertificateConfirmedCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - void (*handler)(Dali::WebEngineCertificate*) = (void (*)(Dali::WebEngineCertificate*))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterCertificateConfirmedCallback([handler](std::unique_ptr certificate) { - handler(certificate.release()); - }); - } - else - { - (arg1)->RegisterCertificateConfirmedCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterSslCertificateChangedCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - void (*handler)(Dali::WebEngineCertificate*) = (void (*)(Dali::WebEngineCertificate*))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterSslCertificateChangedCallback([handler](std::unique_ptr certificate) { - handler(certificate.release()); - }); - } - else - { - (arg1)->RegisterSslCertificateChangedCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterHttpAuthHandlerCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - void (*handler)(Dali::WebEngineHttpAuthHandler*) = (void (*)(Dali::WebEngineHttpAuthHandler*))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterHttpAuthHandlerCallback([handler](std::unique_ptr certificate) { - handler(certificate.release()); - }); - } - else - { - (arg1)->RegisterHttpAuthHandlerCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterContextMenuShownCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - void (*handler)(Dali::WebEngineContextMenu*) = (void (*)(Dali::WebEngineContextMenu*))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterContextMenuShownCallback([handler](std::unique_ptr menu) { - handler(menu.release()); - }); - } - else - { - (arg1)->RegisterContextMenuShownCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterContextMenuHiddenCallback(void * jarg1, void * jarg2) { - Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *)jarg1; - void (*handler)(Dali::WebEngineContextMenu*) = (void (*)(Dali::WebEngineContextMenu*))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterContextMenuHiddenCallback([handler](std::unique_ptr menu) { - handler(menu.release()); - }); - } - else - { - (arg1)->RegisterContextMenuHiddenCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GetPlainTextAsynchronously(void * nuiWebView, void * nuiCallback) { - Dali::Toolkit::WebView *webview = (Dali::Toolkit::WebView *)nuiWebView; - void (*callback)(char*) = (void (*)(char*))nuiCallback; - { - try { - webview->GetPlainTextAsynchronously([callback](const std::string& url) { - callback(SWIG_csharp_string_callback(url.c_str())); - }); - } CALL_CATCH_EXCEPTION(); - } -} - -//----------------------------------WebBackForwardListItem----------------------------------------------------- -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebBackForwardListItem_GetUrl(void * jarg1) { - Dali::WebEngineBackForwardListItem *arg1 = (Dali::WebEngineBackForwardListItem *)0; - std::string result; - arg1 = (Dali::WebEngineBackForwardListItem *)jarg1; - { - try { - result = arg1->GetUrl(); - } CALL_CATCH_EXCEPTION(0); - } - char * jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebBackForwardListItem_GetTitle(void * jarg1) { - Dali::WebEngineBackForwardListItem *arg1 = (Dali::WebEngineBackForwardListItem *)0; - std::string result; - arg1 = (Dali::WebEngineBackForwardListItem *)jarg1; - { - try { - result = (arg1)->GetTitle(); - } CALL_CATCH_EXCEPTION(0); - } - char * jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebBackForwardListItem_GetOriginalUrl(void * jarg1) { - Dali::WebEngineBackForwardListItem *arg1 = (Dali::WebEngineBackForwardListItem *)0; - std::string result; - arg1 = (Dali::WebEngineBackForwardListItem *)jarg1; - { - try { - result = (arg1)->GetOriginalUrl(); - } CALL_CATCH_EXCEPTION(0); - } - char * jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -//----------------------------------WebBackForwardList----------------------------------------------------- -SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetItemCount(void * jarg1) { - Dali::Toolkit::WebBackForwardList *arg1 = (Dali::Toolkit::WebBackForwardList *)0; - uint32_t result = 0; - arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1; - { - try { - result = (arg1)->GetItemCount(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetCurrentItem(void *jarg1) { - Dali::WebEngineBackForwardListItem *result = 0; - Dali::Toolkit::WebBackForwardList *arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1; - { - try { - std::unique_ptr temp = (arg1)->GetCurrentItem(); - result = temp.release(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetPreviousItem(void* jarg1) { - Dali::WebEngineBackForwardListItem *result = 0; - Dali::Toolkit::WebBackForwardList* arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1; - { - try { - std::unique_ptr temp = (arg1)->GetPreviousItem(); - result = temp.release(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetNextItem(void* jarg1) { - Dali::WebEngineBackForwardListItem *result = 0; - Dali::Toolkit::WebBackForwardList* arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1; - { - try { - std::unique_ptr temp = (arg1)->GetNextItem(); - result = temp.release(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetItemAtIndex(void *jarg1, int jarg2) { - Dali::WebEngineBackForwardListItem *result = 0; - Dali::Toolkit::WebBackForwardList *arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1; - { - try { - std::unique_ptr temp = (arg1)->GetItemAtIndex(jarg2); - result = temp.release(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebBackForwardList_DeleteItem(void *jarg1) { - Dali::WebEngineBackForwardListItem *arg1 = (Dali::WebEngineBackForwardListItem *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetBackwardItems(void *jarg1, int jarg2) { - std::vector> *result = 0; - Dali::Toolkit::WebBackForwardList *arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1; - { - try { - result = new std::vector>(); - std::vector> temp = (arg1)->GetBackwardItems(jarg2); - result->swap(temp); - } CALL_CATCH_EXCEPTION(0); - } - return (void *)result; -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetForwardItems(void *jarg1, int jarg2) { - std::vector> *result = 0; - Dali::Toolkit::WebBackForwardList *arg1 = (Dali::Toolkit::WebBackForwardList *)jarg1; - { - try { - result = new std::vector>(); - std::vector> temp = (arg1)->GetForwardItems(jarg2); - result->swap(temp); - } CALL_CATCH_EXCEPTION(0); - } - return (void *)result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebBackForwardList_DeleteCopiedItems(void *jarg1) { - std::vector> *arg1 = (std::vector> *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetCopiedItemsCount(void *jarg1) { - unsigned int result = 0; - std::vector> *arg1 = (std::vector> *)jarg1; - { - try { - result = (arg1)->size(); - } CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WebBackForwardList_GetItemAtIndexFromCopiedItems(void *jarg1, unsigned int jarg2) { - Dali::WebEngineBackForwardListItem *result = 0; - std::vector> *arg1 = (std::vector> *)jarg1; - { - try { - result = (arg1)->operator[](jarg2).get(); - } CALL_CATCH_EXCEPTION(0); - } - return (void *)result; -} - -//----------------------------------WebConsoleMessage----------------------------------------------------- -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebConsoleMessage(void * jarg1) { - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebConsoleMessage is null", 0); - return; - } - - Dali::WebEngineConsoleMessage* arg1 = (Dali::WebEngineConsoleMessage*)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebConsoleMessage_GetSource(void* jarg1) { - Dali::WebEngineConsoleMessage* arg1 = (Dali::WebEngineConsoleMessage*)jarg1; - std::string result; - { - try { - result = arg1->GetSource(); - } CALL_CATCH_EXCEPTION(0); - } - char* jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebConsoleMessage_GetLine(void* jarg1) { - Dali::WebEngineConsoleMessage* arg1 = (Dali::WebEngineConsoleMessage*)jarg1; - uint32_t result; - { - try { - result = arg1->GetLine(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebConsoleMessage_GetSeverityLevel(void* jarg1) { - Dali::WebEngineConsoleMessage* arg1 = (Dali::WebEngineConsoleMessage*)jarg1; - int result; - { - try { - result = (int)arg1->GetSeverityLevel(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebConsoleMessage_GetText(void* jarg1) { - Dali::WebEngineConsoleMessage* arg1 = (Dali::WebEngineConsoleMessage*)jarg1; - std::string result; - { - try { - result = arg1->GetText(); - } CALL_CATCH_EXCEPTION(0); - } - char* jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -//----------------------------------WebCertificate----------------------------------------------------- -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebCertificate(void * jarg1) { - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebCertificate is null", 0); - return; - } - - Dali::WebEngineCertificate* arg1 = (Dali::WebEngineCertificate*)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebCertificate_Allow(void * jarg1, bool jarg2) { - Dali::WebEngineCertificate *arg1 = (Dali::WebEngineCertificate*)jarg1; - { - try { - (arg1)->Allow(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebCertificate_IsFromMainFrame(void * jarg1) { - Dali::WebEngineCertificate* arg1 = (Dali::WebEngineCertificate*)jarg1; - bool ret; - { - try { - ret = (arg1)->IsFromMainFrame(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT const char *SWIGSTDCALL CSharp_Dali_WebCertificate_GetPem(void * jarg1) { - Dali::WebEngineCertificate* arg1 = (Dali::WebEngineCertificate*)jarg1; - std::string result; - { - try { - result = (arg1)->GetPem(); - } CALL_CATCH_EXCEPTION(0); - } - char *jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebCertificate_IsContextSecure(void * jarg1) { - Dali::WebEngineCertificate* arg1 = (Dali::WebEngineCertificate*)jarg1; - bool ret; - { - try { - ret = (arg1)->IsContextSecure(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -//----------------------------------WebContext----------------------------------------------------- -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebContext_GetCacheModel(void * jarg1) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - int ret; - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - ret = (int)(arg1)->GetCacheModel(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetCacheModel(void * jarg1, int jarg2) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - (arg1)->SetCacheModel((Dali::WebEngineContext::CacheModel)jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetProxyUri(void * jarg1, const char * jarg2) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - - arg1 = (Dali::WebEngineContext *)jarg1; - std::string arg2_str(jarg2); - { - try { - (arg1)->SetProxyUri(arg2_str); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebContext_GetProxyUri(void *jarg1) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - char *jresult; - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - const std::string str = (arg1)->GetProxyUri(); - jresult = SWIG_csharp_string_callback(str.c_str()); - } CALL_CATCH_EXCEPTION(0); - } - - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetProxyBypassRule(void *jarg1, char *jarg2, char *jarg3) { - if (!jarg2 || !jarg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return; - } - - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - const std::string arg2(jarg2); - const std::string arg3(jarg3); - - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - (arg1)->SetProxyBypassRule(arg2, arg3); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebContext_GetProxyBypassRule(void *jarg1) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - char *jresult; - - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - const std::string str = (arg1)->GetProxyBypassRule(); - jresult = SWIG_csharp_string_callback(str.c_str()); - } CALL_CATCH_EXCEPTION(0); - } - - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetCertificateFilePath(void * jarg1, const char * jarg2) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - - arg1 = (Dali::WebEngineContext *)jarg1; - std::string arg2_str(jarg2); - { - try { - (arg1)->SetCertificateFilePath(arg2_str); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebContext_GetCertificateFilePath(void *jarg1) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - char *jresult; - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - const std::string str = (arg1)->GetCertificateFilePath(); - jresult = SWIG_csharp_string_callback(str.c_str()); - } CALL_CATCH_EXCEPTION(0); - } - - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetDefaultProxyAuth(void * jarg1, const char * jarg2, const char * jarg3) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; - std::string arg2_str(jarg2); - std::string arg3_str(jarg3); - { - try { - (arg1)->SetDefaultProxyAuth(arg2_str, arg3_str); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_DeleteAllWebDatabase(void *jarg1) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - (arg1)->DeleteAllWebDatabase(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_GetWebDatabaseOrigins(void *jarg1, void *jarg2) { - Dali::WebEngineContext * arg1 = (Dali::WebEngineContext *)jarg1; - void (*handler)(std::vector>*) = (void (*)(std::vector>*))jarg2; - bool result = false; - { - try { - result = (arg1)->GetWebDatabaseOrigins( - [handler](std::vector>& originList) { - std::vector>* webOriginList = new std::vector>(); - webOriginList->swap(originList); - handler(webOriginList); - }); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_DeleteWebDatabase(void *jarg1, void *jarg2) { - Dali::WebEngineContext * arg1 = (Dali::WebEngineContext *)jarg1; - Dali::WebEngineSecurityOrigin * origin = (Dali::WebEngineSecurityOrigin *)jarg2; - bool result = false; - { - try { - result = (arg1)->DeleteWebDatabase(*origin); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_GetWebStorageOrigins(void *jarg1, void *jarg2) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; - void (*handler)(std::vector>*) = (void (*)(std::vector>*))jarg2; - bool result = false; - { - try { - result = (arg1)->GetWebStorageOrigins( - [handler](std::vector>& originList) { - std::vector>* contextOriginList = new std::vector>(); - contextOriginList->swap(originList); - handler(contextOriginList); - }); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_GetWebStorageUsageForOrigin(void *jarg1, void *jarg2, void *jarg3) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; - Dali::WebEngineSecurityOrigin *origin = (Dali::WebEngineSecurityOrigin *)jarg2; - void (*callback)(uint64_t) = (void (*)(uint64_t))jarg3; - bool result = false; - { - try { - result = (arg1)->GetWebStorageUsageForOrigin(*origin, callback); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_DeleteAllWebStorage(void *jarg1) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - (arg1)->DeleteAllWebStorage(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_DeleteWebStorage(void *jarg1, void *jarg2) { - Dali::WebEngineContext * arg1 = (Dali::WebEngineContext *)jarg1; - Dali::WebEngineSecurityOrigin * origin = (Dali::WebEngineSecurityOrigin *)jarg2; - bool result = false; - { - try { - result = (arg1)->DeleteWebStorage(*origin); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_DeleteLocalFileSystem(void *jarg1) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - (arg1)->DeleteLocalFileSystem(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_ClearCache(void * jarg1) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - (arg1)->ClearCache(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_DeleteApplicationCache(void * jarg1, void * jarg2) { - Dali::WebEngineContext * arg1 = (Dali::WebEngineContext *)jarg1; - Dali::WebEngineSecurityOrigin * origin = (Dali::WebEngineSecurityOrigin *)jarg2; - bool result = false; - { - try { - result = (arg1)->DeleteApplicationCache(*origin); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_GetFormPasswordList(void *jarg1, void *jarg2) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; - void (*handler)(std::vector>*) = (void (*)(std::vector>*))jarg2; - { - try { - (arg1)->GetFormPasswordList( - [handler](std::vector>& passwordList) { - std::vector>* contextPasswordList = new std::vector>(); - contextPasswordList->swap(passwordList); - handler(contextPasswordList); - }); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_RegisterDownloadStartedCallback(void * jarg1, void * jarg2) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; - void (*handler)(char *) = (void (*)(char *))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterDownloadStartedCallback( - [handler](const std::string& url) { - handler(SWIG_csharp_string_callback(url.c_str())); - }); - } - else - { - (arg1)->RegisterDownloadStartedCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_RegisterMimeOverriddenCallback(void *jarg1, void *jarg2) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; - bool (*handler)(char *, char *, char *) = (bool (*)(char *, char *, char *))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterMimeOverriddenCallback( - [handler](const std::string& url, const std::string& mime, std::string& newMime) -> bool { - return handler(SWIG_csharp_string_callback(url.c_str()), - SWIG_csharp_string_callback(mime.c_str()), - SWIG_csharp_string_callback(newMime.c_str())); - }); - } - else - { - (arg1)->RegisterMimeOverriddenCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_RegisterRequestInterceptedCallback(void * jarg1, void * jarg2) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)jarg1; - void (*handler)(Dali::WebEngineRequestInterceptorPtr*) = (void (*)(Dali::WebEngineRequestInterceptorPtr*))jarg2; - { - try { - if (handler) - { - (arg1)->RegisterRequestInterceptedCallback([handler](Dali::WebEngineRequestInterceptorPtr interceptor) { - Dali::WebEngineRequestInterceptorPtr* interceptorPtr = new Dali::WebEngineRequestInterceptorPtr((const Dali::WebEngineRequestInterceptorPtr&)interceptor); - handler(interceptorPtr); - }); - } - else - { - (arg1)->RegisterRequestInterceptedCallback(nullptr); - } - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_EnableCache(void * jarg1, bool jarg2) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - (arg1)->EnableCache(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_IsCacheEnabled(void *jarg1) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - bool ret; - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - ret = (arg1)->IsCacheEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetAppId(void *jarg1, char *jarg2) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return; - } - - const std::string str(jarg2); - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - (arg1)->SetAppId(str); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_SetAppVersion(void *jarg1, char *jarg2) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return false; - } - - const std::string str(jarg2); - bool ret; - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - ret = (arg1)->SetAppVersion(str); - } CALL_CATCH_EXCEPTION(0); - } - - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetApplicationType(void *jarg1, int jarg2) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - (arg1)->SetApplicationType((Dali::WebEngineContext::ApplicationType)jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetTimeOffset(void *jarg1, float jarg2) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - (arg1)->SetTimeOffset(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetTimeZoneOffset(void *jarg1, float jarg2, float jarg3) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - (arg1)->SetTimeZoneOffset(jarg2, jarg3); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_RegisterUrlSchemesAsCorsEnabled(void *jarg1, char **jarg2, unsigned int jarg3) { - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return; - } - - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - std::vector vecStr; - for (unsigned int i=0; iRegisterUrlSchemesAsCorsEnabled(vecStr); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_RegisterJsPluginMimeTypes(void *jarg1, char **jarg2, unsigned int jarg3) { - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return; - } - - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - std::vector vecStr; - for (unsigned int i=0; iRegisterJsPluginMimeTypes(vecStr); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_SetDefaultZoomFactor(void *jarg1, float jarg2) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - (arg1)->SetDefaultZoomFactor(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WebContext_GetDefaultZoomFactor(void *jarg1) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - float ret; - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - ret = (arg1)->GetDefaultZoomFactor(); - } CALL_CATCH_EXCEPTION(0); - } - - return ret; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_DeleteAllApplicationCache(void *jarg1) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - bool ret; - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - ret = (arg1)->DeleteAllApplicationCache(); - } CALL_CATCH_EXCEPTION(0); - } - - return ret; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_DeleteAllWebIndexedDatabase(void *jarg1) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - bool ret; - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - ret = (arg1)->DeleteAllWebIndexedDatabase(); - } CALL_CATCH_EXCEPTION(0); - } - - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_DeleteFormPasswordDataList(void *jarg1, char **jarg2, unsigned int jarg3) { - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return; - } - - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - std::vector vecStr; - for (unsigned int i=0; iDeleteFormPasswordDataList(vecStr); - } CALL_CATCH_EXCEPTION() - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_DeleteAllFormPasswordData(void *jarg1) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - (arg1)->DeleteAllFormPasswordData(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebContext_DeleteAllFormCandidateData(void *jarg1) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - (arg1)->DeleteAllFormCandidateData(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContext_FreeUnusedMemory(void *jarg1) { - Dali::WebEngineContext *arg1 = (Dali::WebEngineContext *)0; - bool ret; - arg1 = (Dali::WebEngineContext *)jarg1; - { - try { - ret = (arg1)->FreeUnusedMemory(); - } CALL_CATCH_EXCEPTION(0); - } - - return ret; -} - -//----------------------------------WebContextMenu--------------------------------------------------- -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebContextMenu(void * jarg1) { - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebContextMenu is null", 0); - return; - } - - Dali::WebEngineContextMenu* arg1 = (Dali::WebEngineContextMenu*)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebContextMenu_GetItemCount(void *jarg1) { - Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1; - uint32_t ret; - { - try { - ret = (arg1)->GetItemCount(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebContextMenu_GetItemAt(void *jarg1, uint32_t jarg2) { - Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1; - Dali::WebEngineContextMenuItem *result = 0; - { - try { - std::unique_ptr item = (arg1)->GetItemAt(jarg2); - result = item.release(); - } CALL_CATCH_EXCEPTION(0); - } - return (void *)result; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebContextMenu_GetItemList(void *jarg1) { - Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1; - std::vector>* result = nullptr; - { - try { - result = new std::vector>(); - std::vector> itemList = (arg1)->GetItemList(); - result->swap(itemList); - } CALL_CATCH_EXCEPTION(0); - } - return (void *)result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContextMenu_RemoveItem(void *jarg1, void *jarg2) { - Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1; - bool result = 0; - { - try { - result = (arg1)->RemoveItem(*((Dali::WebEngineContextMenuItem*)jarg2)); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContextMenu_AppendItemAsAction(void *jarg1, int jarg2, const char *jarg3, bool jarg4) { - Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1; - bool result = 0; - { - try { - result = (arg1)->AppendItemAsAction((Dali::WebEngineContextMenuItem::ItemTag)jarg2, jarg3, jarg4); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContextMenu_AppendItem(void *jarg1, int jarg2, const char *jarg3, const char *jarg4, bool jarg5) { - Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1; - bool result = 0; - { - try { - result = (arg1)->AppendItem((Dali::WebEngineContextMenuItem::ItemTag)jarg2, jarg3, jarg4, jarg5); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContextMenu_SelectItem(void *jarg1, void *jarg2) { - Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1; - bool result = 0; - { - try { - result = (arg1)->SelectItem(*((Dali::WebEngineContextMenuItem*)jarg2)); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContextMenu_Hide(void *jarg1) { - Dali::WebEngineContextMenu *arg1 = (Dali::WebEngineContextMenu *)jarg1; - bool result = 0; - { - try { - result = (arg1)->Hide(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -//----------------------------------WebContextMenuItem--------------------------------------------------- -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebContextMenuItem(void * jarg1) { - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebContextMenuItem is null", 0); - return; - } - - Dali::WebEngineContextMenuItem* arg1 = (Dali::WebEngineContextMenuItem*)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebContextMenuItem_GetTag(void *jarg1) { - Dali::WebEngineContextMenuItem *arg1 = (Dali::WebEngineContextMenuItem *)jarg1; - int result = 0; - { - try { - result = (int)(arg1)->GetTag(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebContextMenuItem_GetType(void *jarg1) { - Dali::WebEngineContextMenuItem *arg1 = (Dali::WebEngineContextMenuItem *)jarg1; - int result = 0; - { - try { - result = (int)(arg1)->GetType(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebContextMenuItem_IsEnabled(void *jarg1) { - Dali::WebEngineContextMenuItem *arg1 = (Dali::WebEngineContextMenuItem *)jarg1; - bool result = 0; - { - try { - result = (arg1)->IsEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebContextMenuItem_GetLinkUrl(void *jarg1) { - Dali::WebEngineContextMenuItem *arg1 = (Dali::WebEngineContextMenuItem *)jarg1; - std::string result; - { - try { - result = (arg1)->GetLinkUrl(); - } CALL_CATCH_EXCEPTION(0); - } - char *jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebContextMenuItem_GetImageUrl(void *jarg1) { - Dali::WebEngineContextMenuItem *arg1 = (Dali::WebEngineContextMenuItem *)jarg1; - std::string result; - { - try { - result = (arg1)->GetImageUrl(); - } CALL_CATCH_EXCEPTION(0); - } - char *jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebContextMenuItem_GetTitle(void *jarg1) { - Dali::WebEngineContextMenuItem *arg1 = (Dali::WebEngineContextMenuItem *)jarg1; - std::string result; - { - try { - result = (arg1)->GetTitle(); - } CALL_CATCH_EXCEPTION(0); - } - char *jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebContextMenuItem_GetParentMenu(void *jarg1) { - Dali::WebEngineContextMenuItem* arg1 = (Dali::WebEngineContextMenuItem*)jarg1; - Dali::WebEngineContextMenu* result = 0; - { - try { - std::unique_ptr item = (arg1)->GetParentMenu(); - result = item.release(); - } CALL_CATCH_EXCEPTION(0); - } - return (void *)result; -} - -//----------------------------------WebContextMenuItemList--------------------------------------------------- -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebContextMenu_ItemList(void * jarg1) { - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebContextMenu ItemList is null", 0); - return; - } - - std::vector>* arg1 = (std::vector>*)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebContextMenu_ItemList_GetItemCount(void* jarg1) { - std::vector>* arg1 = (std::vector>*)jarg1; - uint32_t result = 0; - { - try { - result = (arg1)->size(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebContextMenu_ItemList_ValueOfIndex(void* jarg1, unsigned int jarg2) { - std::vector>* arg1 = (std::vector>*)jarg1; - Dali::WebEngineContextMenuItem* result = 0; - { - try { - result = ((arg1)->operator[](jarg2)).get(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -//----------------------------------WebCookieManager--------------------------------------------------- -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebCookieManager_GetCookieAcceptPolicy(void * jarg1) { - Dali::WebEngineCookieManager* arg1 = (Dali::WebEngineCookieManager*)0; - int ret; - - arg1 = (Dali::WebEngineCookieManager*)jarg1; - { - try { - ret = (int)(arg1)->GetCookieAcceptPolicy(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebCookieManager_SetCookieAcceptPolicy(void * jarg1, int jarg2) { - Dali::WebEngineCookieManager* arg1 = (Dali::WebEngineCookieManager*)0; - arg1 = (Dali::WebEngineCookieManager*)jarg1; - { - try { - (arg1)->SetCookieAcceptPolicy( - (Dali::WebEngineCookieManager::CookieAcceptPolicy)jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebCookieManager_SetPersistentStorage(void * jarg1, const char * jarg2, int jarg3) { - Dali::WebEngineCookieManager* arg1 = (Dali::WebEngineCookieManager*)0; - - arg1 = (Dali::WebEngineCookieManager*)jarg1; - std::string arg2_str(jarg2); - Dali::WebEngineCookieManager::CookiePersistentStorage arg3_enum = (Dali::WebEngineCookieManager::CookiePersistentStorage)jarg3; - { - try { - (arg1)->SetPersistentStorage(arg2_str, arg3_enum); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebCookieManager_ClearCookies(void * jarg1) { - Dali::WebEngineCookieManager* arg1 = (Dali::WebEngineCookieManager*)0; - - arg1 = (Dali::WebEngineCookieManager*)jarg1; - { - try { - (arg1)->ClearCookies(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebCookieManager_ChangesWatch(void *jarg1, void *jarg2) { - Dali::WebEngineCookieManager *arg1 = (Dali::WebEngineCookieManager *)jarg1; - void (*callback)() = (void (*)())jarg2; - { - try { - (arg1)->ChangesWatch(callback); - } CALL_CATCH_EXCEPTION(); - } -} - -//----------------------------------WebFormRepostDecision--------------------------------------------------- -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebFormRepostDecision(void * jarg1) { - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebFormRepostDecision is null", 0); - return; - } - - Dali::WebEngineFormRepostDecision* arg1 = (Dali::WebEngineFormRepostDecision*)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebFormRepostDecision_Reply(void *jarg1, bool jarg2) { - Dali::WebEngineFormRepostDecision* arg1 = (Dali::WebEngineFormRepostDecision*)jarg1; - { - try { - arg1->Reply(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -//----------------------------------WebFrame--------------------------------------------------- -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebFrame_IsMainFrame(void* jarg1) { - Dali::WebEngineFrame* arg1 = (Dali::WebEngineFrame*)jarg1; - bool result = false; - { - try { - result = (arg1)->IsMainFrame(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -//----------------------------------WebPolicyDecision----------------------------------------------------- -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebPolicyDecision(void * jarg1) { - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebPolicyDecision is null", 0); - return; - } - - Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetUrl(void* jarg1) { - Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; - std::string result; - { - try { - result = arg1->GetUrl(); - } CALL_CATCH_EXCEPTION(0); - } - char* jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetCookie(void* jarg1) { - Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; - std::string result; - { - try { - result = arg1->GetCookie(); - } CALL_CATCH_EXCEPTION(0); - } - char* jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetDecisionType(void* jarg1) { - Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; - int result; - { - try { - result = (int)arg1->GetDecisionType(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetResponseMime(void* jarg1) { - Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; - std::string result; - { - try { - result = arg1->GetResponseMime(); - } CALL_CATCH_EXCEPTION(0); - } - char* jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetResponseStatusCode(void* jarg1) { - Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; - int result; - { - try { - result = arg1->GetResponseStatusCode(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetNavigationType(void* jarg1) { - Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; - int result; - { - try { - result = (int)arg1->GetNavigationType(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetFrame(void* jarg1) { - Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; - Dali::WebEngineFrame* result = 0; - { - try { - result = &((arg1)->GetFrame()); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebPolicyDecision_GetScheme(void* jarg1) { - Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; - std::string result; - { - try { - result = arg1->GetScheme(); - } CALL_CATCH_EXCEPTION(0); - } - char* jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebPolicyDecision_Use(void* jarg1) { - Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; - bool result; - { - try { - result = arg1->Use(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebPolicyDecision_Ignore(void* jarg1) { - Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; - bool result; - { - try { - result = arg1->Ignore(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebPolicyDecision_Suspend(void* jarg1) { - Dali::WebEnginePolicyDecision* arg1 = (Dali::WebEnginePolicyDecision*)jarg1; - bool result; - { - try { - result = arg1->Suspend(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -//----------------------------------WebRequestInterceptorPtr--------------------------------------------------- -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebRequestInterceptorPtr(void * jarg1) { - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebRequestInterceptorPtr is null", 0); - return; - } - - Dali::WebEngineRequestInterceptorPtr* arg1 = (Dali::WebEngineRequestInterceptorPtr*)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebRequestInterceptorPtr_Get(void * jarg1) { - Dali::WebEngineRequestInterceptorPtr* arg1 = (Dali::WebEngineRequestInterceptorPtr*)jarg1; - Dali::WebEngineRequestInterceptor* result = 0; - { - try { - result = arg1->Get(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -//----------------------------------WebRequestInterceptor--------------------------------------------------- -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_GetWebView(void * jarg1) { - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebRequestInterceptor is null", 0); - return 0; - } - - Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; - Dali::Toolkit::WebView result; - - Dali::WebEnginePlugin* plugin = nullptr; - { - try { - plugin = (arg1)->GetWebEngine(); - } CALL_CATCH_EXCEPTION(0); - } - - if (!plugin) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebEnginePlugin is null", 0); - return 0; - } - - { - try { - result = Dali::Toolkit::WebView::FindWebView(plugin); - } CALL_CATCH_EXCEPTION(0); - } - void* jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView&)result); - return jresult; -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_GetUrl(void * jarg1) { - Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; - std::string result; - { - try { - result = (arg1)->GetUrl(); - } CALL_CATCH_EXCEPTION(0); - } - char* jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_GetMethod(void * jarg1) { - Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; - std::string result; - { - try { - result = (arg1)->GetMethod(); - } CALL_CATCH_EXCEPTION(0); - } - char* jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_GetHeaders(void * jarg1) { - Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; - Dali::Property::Map * result = 0; - { - try { - Dali::Property::Map headers = (arg1)->GetHeaders(); - result = new Dali::Property::Map(headers); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_Ignore(void * jarg1) { - Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; - bool ret = false; - { - try { - ret = (arg1)->Ignore(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_SetResponseStatus(void * jarg1, int jarg2, const char *jarg3) { - Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; - bool ret = false; - std::string arg3_str(jarg3); - { - try { - ret = (arg1)->SetResponseStatus(jarg2, arg3_str); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_AddResponseHeader(void * jarg1, const char * jarg2, const char * jarg3) { - Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; - bool ret = false; - std::string arg2_str(jarg2); - std::string arg3_str(jarg3); - { - try { - ret = (arg1)->AddResponseHeader(arg2_str, arg3_str); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_AddResponseHeaders(void * jarg1, void * jarg2) { - Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; - Dali::Property::Map* arg2 = (Dali::Property::Map*)jarg2; - bool ret = false; - { - try { - ret = (arg1)->AddResponseHeaders(*arg2); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_AddResponseBody(void * jarg1, const int8_t * jarg2, uint32_t jarg3) { - Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; - bool ret = false; - { - try { - ret = (arg1)->AddResponseBody(jarg2, jarg3); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_AddResponse(void * jarg1, const char * jarg2, const int8_t * jarg3, uint32_t jarg4) { - Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; - bool ret = false; - std::string arg2_str(jarg2); - { - try { - ret = (arg1)->AddResponse(arg2_str, jarg3, jarg4); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebRequestInterceptor_WriteResponseChunk(void * jarg1, const int8_t * jarg2, uint32_t jarg3) { - Dali::WebEngineRequestInterceptor* arg1 = (Dali::WebEngineRequestInterceptor*)jarg1; - bool ret = false; - { - try { - ret = (arg1)->WriteResponseChunk(jarg2, jarg3); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -//----------------------------------WebHttpAuthHandler--------------------------------------------------- -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebHttpAuthHandler(void * jarg1) { - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebHttpAuthHandler is null", 0); - return; - } - - Dali::WebEngineHttpAuthHandler* arg1 = (Dali::WebEngineHttpAuthHandler*)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT const char *SWIGSTDCALL CSharp_Dali_WebHttpAuthHandler_GetRealm(void * jarg1) { - Dali::WebEngineHttpAuthHandler* arg1 = (Dali::WebEngineHttpAuthHandler*)jarg1; - std::string result; - { - try { - result = (arg1)->GetRealm(); - } CALL_CATCH_EXCEPTION(0); - } - char *jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebHttpAuthHandler_Suspend(void * jarg1) { - Dali::WebEngineHttpAuthHandler* arg1 = (Dali::WebEngineHttpAuthHandler*)jarg1; - { - try { - (arg1)->Suspend(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebHttpAuthHandler_UseCredential( - void * jarg1, const char *jarg2, const char *jarg3) { - Dali::WebEngineHttpAuthHandler* arg1 = (Dali::WebEngineHttpAuthHandler*)jarg1; - std::string arg2_str(jarg2); - std::string arg3_str(jarg3); - { - try { - (arg1)->UseCredential(arg2_str, arg3_str); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebHttpAuthHandler_CancelCredential(void * jarg1) { - Dali::WebEngineHttpAuthHandler* arg1 = (Dali::WebEngineHttpAuthHandler*)jarg1; - { - try { - (arg1)->CancelCredential(); - } CALL_CATCH_EXCEPTION(); - } -} - -//----------------------------------WebPasswordData--------------------------------------------------- -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebPasswordData_GetUrl(void * jarg1) { - Dali::WebEngineContext::PasswordData *arg1 = (Dali::WebEngineContext::PasswordData *)jarg1; - std::string result; - { - try { - result = (arg1)->url; - } CALL_CATCH_EXCEPTION(0); - } - char * jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebPasswordData_GetUseFingerprint(void * jarg1) { - Dali::WebEngineContext::PasswordData * arg1 = (Dali::WebEngineContext::PasswordData *)jarg1; - bool result = false; - { - try { - result = (arg1)->useFingerprint; - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -//----------------------------------WebLoadError----------------------------------------------------- -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebLoadError(void * jarg1) { - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebLoadError is null", 0); - return; - } - - Dali::WebEngineLoadError* arg1 = (Dali::WebEngineLoadError*)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebLoadError_GetUrl(void* jarg1) { - Dali::WebEngineLoadError* arg1 = (Dali::WebEngineLoadError*)jarg1; - std::string result; - { - try { - result = arg1->GetUrl(); - } CALL_CATCH_EXCEPTION(0); - } - char* jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebLoadError_GetCode(void* jarg1) { - Dali::WebEngineLoadError* arg1 = (Dali::WebEngineLoadError*)jarg1; - int result; - { - try { - result = (int)arg1->GetCode(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT const char* SWIGSTDCALL CSharp_Dali_WebLoadError_GetDescription(void* jarg1) { - Dali::WebEngineLoadError* arg1 = (Dali::WebEngineLoadError*)jarg1; - std::string result; - { - try { - result = arg1->GetDescription(); - } CALL_CATCH_EXCEPTION(0); - } - char* jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebLoadError_GetType(void* jarg1) { - Dali::WebEngineLoadError* arg1 = (Dali::WebEngineLoadError*)jarg1; - int result; - { - try { - result = (int)arg1->GetType(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -//----------------------------------WebPasswordDataList--------------------------------------------------- -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebPasswordDataList(void * jarg1) { - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebEngineContext::PasswordData List is null", 0); - return; - } - - std::vector>* arg1 = (std::vector>*)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebPasswordDataList_GetItemCount(void* jarg1) { - std::vector>* arg1 = (std::vector>*)jarg1; - uint32_t result = 0; - { - try { - result = (arg1)->size(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebPasswordDataList_ValueOfIndex(void * jarg1, unsigned int jarg2) { - std::vector>* arg1 = (std::vector>*)jarg1; - Dali::WebEngineContext::PasswordData* result = 0; - { - try { - result = ((arg1)->operator[](jarg2)).get(); - } CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -//----------------------------------WebSecurityOrigin--------------------------------------------------- -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebSecurityOrigin_GetHost(void * jarg1) { - Dali::WebEngineSecurityOrigin *arg1 = (Dali::WebEngineSecurityOrigin *)jarg1; - std::string result; - { - try { - result = (arg1)->GetHost(); - } CALL_CATCH_EXCEPTION(0); - } - char * jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebSecurityOrigin_GetProtocol(void * jarg1) { - Dali::WebEngineSecurityOrigin *arg1 = (Dali::WebEngineSecurityOrigin *)jarg1; - std::string result; - { - try { - result = (arg1)->GetProtocol(); - } CALL_CATCH_EXCEPTION(0); - } - char * jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -//----------------------------------WebSecurityOriginList--------------------------------------------------- -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebSecurityOriginList(void *jarg1) { - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebEngineSecurityOrigin List is null", 0); - return; - } - - std::vector>* arg1 = (std::vector>*)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT uint32_t SWIGSTDCALL CSharp_Dali_WebSecurityOriginList_GetItemCount(void* jarg1) { - std::vector>* arg1 = (std::vector>*)jarg1; - uint32_t result = 0; - { - try { - result = (arg1)->size(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebSecurityOriginList_ValueOfIndex(void *jarg1, unsigned int jarg2) { - std::vector>* arg1 = (std::vector>*)jarg1; - Dali::WebEngineSecurityOrigin * result = 0; - { - try { - result = ((arg1)->operator[](jarg2)).get(); - } CALL_CATCH_EXCEPTION(0); - } - return result; -} - -//----------------------------------WebHitTest--------------------------------------------------- -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebHitTest(void * jarg1) { - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "WebEngineHitTest is null", 0); - return; - } - - Dali::WebEngineHitTest* arg1 = (Dali::WebEngineHitTest*)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebHitTest_GetResultContext(void * jarg1) { - Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1; - int ret; - { - try { - ret = (int)(arg1)->GetResultContext(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetLinkUri(void * jarg1) { - Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1; - std::string result; - { - try { - result = (arg1)->GetLinkUri(); - } CALL_CATCH_EXCEPTION(0); - } - char *jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetLinkTitle(void * jarg1) { - Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1; - std::string result; - { - try { - result = (arg1)->GetLinkTitle(); - } CALL_CATCH_EXCEPTION(0); - } - char *jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetLinkLabel(void * jarg1) { - Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1; - std::string result; - { - try { - result = (arg1)->GetLinkLabel(); - } CALL_CATCH_EXCEPTION(0); - } - char *jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetImageUri(void * jarg1) { - Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1; - std::string result; - { - try { - result = (arg1)->GetImageUri(); - } CALL_CATCH_EXCEPTION(0); - } - char * jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetMediaUri(void * jarg1) { - Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1; - std::string result; - { - try { - result = (arg1)->GetMediaUri(); - } CALL_CATCH_EXCEPTION(0); - } - char * jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetTagName(void * jarg1) { - Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1; - std::string result; - { - try { - result = (arg1)->GetTagName(); - } CALL_CATCH_EXCEPTION(0); - } - char *jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetNodeValue(void * jarg1) { - Dali::WebEngineHitTest * arg1 = (Dali::WebEngineHitTest *)jarg1; - std::string result; - { - try { - result = (arg1)->GetNodeValue(); - } CALL_CATCH_EXCEPTION(0); - } - char * jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebHitTest_GetAttributes(void * jarg1) { - Dali::WebEngineHitTest * arg1 = (Dali::WebEngineHitTest *)jarg1; - Dali::Property::Map * result = 0; - { - try { - Dali::Property::Map attributes = (arg1)->GetAttributes(); - result = new Dali::Property::Map(attributes); - } CALL_CATCH_EXCEPTION(0); - } - return (void *)result; -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebHitTest_GetImageFileNameExtension(void * jarg1) { - Dali::WebEngineHitTest *arg1 = (Dali::WebEngineHitTest *)jarg1; - std::string result; - { - try { - result = (arg1)->GetImageFileNameExtension(); - } CALL_CATCH_EXCEPTION(0); - } - char *jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebHitTest_GetImageBuffer(void * jarg1) { - Dali::WebEngineHitTest* arg1 = (Dali::WebEngineHitTest *)jarg1; - Dali::PixelData result; - { - try { - result = (arg1)->GetImageBuffer(); - } CALL_CATCH_EXCEPTION(0); - } - - Dali::PixelData* jresult = new Dali::PixelData((const Dali::PixelData &)result); - return (void *)jresult; -} - -//----------------------------------WebSettings--------------------------------------------------- -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_AllowMixedContents(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - (arg1)->AllowMixedContents(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableSpatialNavigation(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - (arg1)->EnableSpatialNavigation(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebSettings_GetDefaultFontSize(void * jarg1) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - int ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->GetDefaultFontSize(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_SetDefaultFontSize(void * jarg1, int jarg2) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - (arg1)->SetDefaultFontSize(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableWebSecurity(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - (arg1)->EnableWebSecurity(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableCacheBuilder(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; - - arg1 = (Dali::Toolkit::WebSettings*)jarg1; - { - try { - (arg1)->EnableCacheBuilder(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_UseScrollbarThumbFocusNotifications(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; - - arg1 = (Dali::Toolkit::WebSettings*)jarg1; - { - try { - (arg1)->UseScrollbarThumbFocusNotifications(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableDoNotTrack(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; - - arg1 = (Dali::Toolkit::WebSettings*)jarg1; - { - try { - (arg1)->EnableDoNotTrack(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_AllowFileAccessFromExternalUrl(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - (arg1)->AllowFileAccessFromExternalUrl(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsJavaScriptEnabled(void * jarg1) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->IsJavaScriptEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableJavaScript(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - (arg1)->EnableJavaScript(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsAutoFittingEnabled(void * jarg1) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->IsAutoFittingEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableAutoFitting(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; - - arg1 = (Dali::Toolkit::WebSettings*)jarg1; - { - try { - (arg1)->EnableAutoFitting(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_ArePluginsEnabled(void * jarg1) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->ArePluginsEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnablePlugins(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; - - arg1 = (Dali::Toolkit::WebSettings*)jarg1; - { - try { - (arg1)->EnablePlugins(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsPrivateBrowsingEnabled(void * jarg1) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->IsPrivateBrowsingEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnablePrivateBrowsing(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; - - arg1 = (Dali::Toolkit::WebSettings*)jarg1; - { - try { - (arg1)->EnablePrivateBrowsing(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsLinkMagnifierEnabled(void * jarg1) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->IsLinkMagnifierEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableLinkMagnifier(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; - - arg1 = (Dali::Toolkit::WebSettings*)jarg1; - { - try { - (arg1)->EnableLinkMagnifier(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsKeypadWithoutUserActionUsed(void * jarg1) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->IsKeypadWithoutUserActionUsed(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_UseKeypadWithoutUserAction(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; - - arg1 = (Dali::Toolkit::WebSettings*)jarg1; - { - try { - (arg1)->UseKeypadWithoutUserAction(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsAutofillPasswordFormEnabled(void * jarg1) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->IsAutofillPasswordFormEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableAutofillPasswordForm(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; - - arg1 = (Dali::Toolkit::WebSettings*)jarg1; - { - try { - (arg1)->EnableAutofillPasswordForm(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsFormCandidateDataEnabled(void * jarg1) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->IsFormCandidateDataEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableFormCandidateData(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; - - arg1 = (Dali::Toolkit::WebSettings*)jarg1; - { - try { - (arg1)->EnableFormCandidateData(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsTextSelectionEnabled(void * jarg1) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->IsTextSelectionEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableTextSelection(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; - - arg1 = (Dali::Toolkit::WebSettings*)jarg1; - { - try { - (arg1)->EnableTextSelection(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsTextAutosizingEnabled(void * jarg1) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->IsTextAutosizingEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableTextAutosizing(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; - - arg1 = (Dali::Toolkit::WebSettings*)jarg1; - { - try { - (arg1)->EnableTextAutosizing(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsArrowScrollEnabled(void * jarg1) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->IsArrowScrollEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableArrowScroll(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; - - arg1 = (Dali::Toolkit::WebSettings*)jarg1; - { - try { - (arg1)->EnableArrowScroll(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsClipboardEnabled(void * jarg1) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->IsClipboardEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableClipboard(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; - - arg1 = (Dali::Toolkit::WebSettings*)jarg1; - { - try { - (arg1)->EnableClipboard(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsImePanelEnabled(void * jarg1) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->IsImePanelEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_EnableImePanel(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings* arg1 = (Dali::Toolkit::WebSettings*) 0; - - arg1 = (Dali::Toolkit::WebSettings*)jarg1; - { - try { - (arg1)->EnableImePanel(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_AllowScriptsOpenWindows(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - (arg1)->AllowScriptsOpenWindows(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_AreImagesLoadedAutomatically(void * jarg1) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->AreImagesLoadedAutomatically(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_AllowImagesLoadAutomatically(void * jarg1, bool jarg2) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - (arg1)->AllowImagesLoadAutomatically(jarg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebSettings_GetDefaultTextEncodingName(void * jarg1) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - std::string result; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - result = (arg1)->GetDefaultTextEncodingName(); - } CALL_CATCH_EXCEPTION(0); - } - char * jresult = SWIG_csharp_string_callback(result.c_str()); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_SetDefaultTextEncodingName(void * jarg1, const char * jarg2) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - std::string arg2_str(jarg2); - { - try { - (arg1)->SetDefaultTextEncodingName(arg2_str); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_SetViewportMetaTag(void *jarg1, bool jarg2) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->SetViewportMetaTag(jarg2); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_SetForceZoom(void *jarg1, bool jarg2) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->SetForceZoom(jarg2); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsZoomForced(void *jarg1) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->IsZoomForced(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_SetTextZoomEnabled(void *jarg1, bool jarg2) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->SetTextZoomEnabled(jarg2); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsTextZoomEnabled(void *jarg1) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->IsTextZoomEnabled(); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebSettings_SetExtraFeature(void *jarg1, const char *jarg2, bool jarg3) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - std::string arg2(jarg2); - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - (arg1)->SetExtraFeature(arg2, jarg3); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebSettings_IsExtraFeatureEnabled(void *jarg1, const char *jarg2) { - Dali::Toolkit::WebSettings *arg1 = (Dali::Toolkit::WebSettings *)0; - std::string arg2(jarg2); - bool ret; - - arg1 = (Dali::Toolkit::WebSettings *)jarg1; - { - try { - ret = (arg1)->IsExtraFeatureEnabled(arg2); - } CALL_CATCH_EXCEPTION(0); - } - return ret; -} - -#ifdef __cplusplus -} // end extern "C" -#endif diff --git a/dali-csharp-binder/src/widget-view-manager-wrap.cpp b/dali-csharp-binder/src/widget-view-manager-wrap.cpp deleted file mode 100755 index cbf5a99d..00000000 --- a/dali-csharp-binder/src/widget-view-manager-wrap.cpp +++ /dev/null @@ -1,242 +0,0 @@ -/* - * Copyright (c) 2017 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - -// EXTERNAL INCLUDES -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - - SWIGEXPORT Dali::BaseHandle *SWIGSTDCALL CSharp_Dali_WidgetViewManager_SWIGUpcast(Dali::WidgetView::WidgetViewManager *jarg1) - { - return (Dali::BaseHandle *)jarg1; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WidgetViewManager_New(void *jarg1, char *jarg2) - { - void *jresult; - Dali::Application arg1; - std::string *arg2 = 0; - Dali::Application *argp1; - Dali::WidgetView::WidgetViewManager result; - - argp1 = (Dali::Application *)jarg1; - if (!argp1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Application", 0); - return 0; - } - arg1 = *argp1; - if (!jarg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try - { - result = Dali::WidgetView::WidgetViewManager::New(arg1, (std::string const &)*arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::WidgetView::WidgetViewManager((const Dali::WidgetView::WidgetViewManager &)result); - - //argout typemap for const std::string& - - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WidgetViewManager_DownCast(void *jarg1) - { - void *jresult; - Dali::BaseHandle arg1; - Dali::BaseHandle *argp1; - Dali::WidgetView::WidgetViewManager 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::WidgetView::WidgetViewManager::DownCast(arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::WidgetView::WidgetViewManager((const Dali::WidgetView::WidgetViewManager &)result); - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_WidgetViewManager__SWIG_0() - { - void *jresult; - Dali::WidgetView::WidgetViewManager *result = 0; - - { - try - { - result = (Dali::WidgetView::WidgetViewManager *)new Dali::WidgetView::WidgetViewManager(); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_WidgetViewManager__SWIG_1(void *jarg1) - { - void *jresult; - Dali::WidgetView::WidgetViewManager *arg1 = 0; - Dali::WidgetView::WidgetViewManager *result = 0; - - arg1 = (Dali::WidgetView::WidgetViewManager *)jarg1; - if (!arg1) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetView::WidgetViewManager const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::WidgetView::WidgetViewManager *)new Dali::WidgetView::WidgetViewManager((Dali::WidgetView::WidgetViewManager const &)*arg1); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WidgetViewManager_Assign(void *jarg1, void *jarg2) - { - void *jresult; - Dali::WidgetView::WidgetViewManager *arg1 = (Dali::WidgetView::WidgetViewManager *)0; - Dali::WidgetView::WidgetViewManager *arg2 = 0; - Dali::WidgetView::WidgetViewManager *result = 0; - - arg1 = (Dali::WidgetView::WidgetViewManager *)jarg1; - arg2 = (Dali::WidgetView::WidgetViewManager *)jarg2; - if (!arg2) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetView::WidgetViewManager const & type is null", 0); - return 0; - } - { - try - { - result = (Dali::WidgetView::WidgetViewManager *)&(arg1)->operator=((Dali::WidgetView::WidgetViewManager const &)*arg2); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; - } - - SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetViewManager(void *jarg1) - { - Dali::WidgetView::WidgetViewManager *arg1 = (Dali::WidgetView::WidgetViewManager *)0; - - arg1 = (Dali::WidgetView::WidgetViewManager *)jarg1; - { - try - { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } - } - - SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WidgetViewManager_AddWidget(void *jarg1, char *jarg2, char *jarg3, int jarg4, int jarg5, float jarg6) - { - void *jresult; - Dali::WidgetView::WidgetViewManager *arg1 = (Dali::WidgetView::WidgetViewManager *)0; - std::string *arg2 = 0; - std::string *arg3 = 0; - int arg4; - int arg5; - float arg6; - Dali::WidgetView::WidgetView result; - - arg1 = (Dali::WidgetView::WidgetViewManager *)jarg1; - 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 = (int)jarg4; - arg5 = (int)jarg5; - arg6 = (float)jarg6; - { - try - { - result = (arg1)->AddWidget((std::string const &)*arg2, (std::string const &)*arg3, arg4, arg5, arg6); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::WidgetView::WidgetView((const Dali::WidgetView::WidgetView &)result); - return jresult; - } - - SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WidgetViewManager_RemoveWidget(void *jarg1, void *jarg2) - { - bool jresult; - Dali::WidgetView::WidgetViewManager *widgetViewManager = (Dali::WidgetView::WidgetViewManager *)0; - Dali::WidgetView::WidgetView *widgetView = (Dali::WidgetView::WidgetView *)0; - bool result; - - widgetViewManager = (Dali::WidgetView::WidgetViewManager *)jarg1; - widgetView = (Dali::WidgetView::WidgetView *)jarg2; - { - try - { - result = (widgetViewManager)->RemoveWidget(*widgetView); - } - CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; - } -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/widget-view-wrap.cpp b/dali-csharp-binder/src/widget-view-wrap.cpp deleted file mode 100755 index 076e7f74..00000000 --- a/dali-csharp-binder/src/widget-view-wrap.cpp +++ /dev/null @@ -1,618 +0,0 @@ -/* - * Copyright (c) 2017 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - -// EXTERNAL INCLUDES -#include - -// INTERNAL INCLUDES -#include "common.h" - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__Empty(Dali::Signal< void (Dali::WidgetView::WidgetView) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WidgetView::WidgetView) > const *self){ - return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__Connect(Dali::Signal< void (Dali::WidgetView::WidgetView) > *self,void (*func)(Dali::WidgetView::WidgetView)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__Disconnect(Dali::Signal< void (Dali::WidgetView::WidgetView) > *self,void (*func)(Dali::WidgetView::WidgetView)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__Emit(Dali::Signal< void (Dali::WidgetView::WidgetView) > *self,Dali::WidgetView::WidgetView arg){ - self->Emit( arg ); -} - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WidgetView_SWIGUpcast(Dali::WidgetView::WidgetView *jarg1) { - return (Dali::Toolkit::Control *)jarg1; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_WIDGET_ID_get() { - int jresult ; - int result; - - result = (int)Dali::WidgetView::WidgetView::Property::WIDGET_ID; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_INSTANCE_ID_get() { - int jresult ; - int result; - - result = (int)Dali::WidgetView::WidgetView::Property::INSTANCE_ID; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_CONTENT_INFO_get() { - int jresult ; - int result; - - result = (int)Dali::WidgetView::WidgetView::Property::CONTENT_INFO; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_TITLE_get() { - int jresult ; - int result; - - result = (int)Dali::WidgetView::WidgetView::Property::TITLE; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_UPDATE_PERIOD_get() { - int jresult ; - int result; - - result = (int)Dali::WidgetView::WidgetView::Property::UPDATE_PERIOD; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_PREVIEW_get() { - int jresult ; - int result; - - result = (int)Dali::WidgetView::WidgetView::Property::PREVIEW; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_LOADING_TEXT_get() { - int jresult ; - int result; - - result = (int)Dali::WidgetView::WidgetView::Property::LOADING_TEXT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_WIDGET_STATE_FAULTED_get() { - int jresult ; - int result; - - result = (int)Dali::WidgetView::WidgetView::Property::WIDGET_STATE_FAULTED; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_PERMANENT_DELETE_get() { - int jresult ; - int result; - - result = (int)Dali::WidgetView::WidgetView::Property::PERMANENT_DELETE; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_RETRY_TEXT_get() { - int jresult ; - int result; - - result = (int)Dali::WidgetView::WidgetView::Property::RETRY_TEXT; - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_EFFECT_get() { - int jresult ; - int result; - - result = (int)Dali::WidgetView::WidgetView::Property::EFFECT; - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetView_Property() { - void * jresult ; - Dali::WidgetView::WidgetView::Property *result = 0 ; - - { - try { - result = (Dali::WidgetView::WidgetView::Property *)new Dali::WidgetView::WidgetView::Property(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetView_Property(void * jarg1) { - Dali::WidgetView::WidgetView::Property *arg1 = (Dali::WidgetView::WidgetView::Property *) 0 ; - - arg1 = (Dali::WidgetView::WidgetView::Property *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetView_New(char * jarg1, char * jarg2, int jarg3, int jarg4, float jarg5) { - void * jresult ; - std::string *arg1 = 0 ; - std::string *arg2 = 0 ; - int arg3 ; - int arg4 ; - float arg5 ; - Dali::WidgetView::WidgetView result; - - if (!jarg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg1_str(jarg1); - arg1 = &arg1_str; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = (int)jarg3; - arg4 = (int)jarg4; - arg5 = (float)jarg5; - { - try { - result = Dali::WidgetView::WidgetView::New((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::WidgetView::WidgetView((const Dali::WidgetView::WidgetView &)result); - - //argout typemap for const std::string& - - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetView_DownCast(void * jarg1) { - void * jresult ; - Dali::BaseHandle arg1 ; - Dali::BaseHandle *argp1 ; - Dali::WidgetView::WidgetView 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::WidgetView::WidgetView::DownCast(arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::WidgetView::WidgetView((const Dali::WidgetView::WidgetView &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetView__SWIG_0() { - void * jresult ; - Dali::WidgetView::WidgetView *result = 0 ; - - { - try { - result = (Dali::WidgetView::WidgetView *)new Dali::WidgetView::WidgetView(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetView__SWIG_1(void * jarg1) { - void * jresult ; - Dali::WidgetView::WidgetView *arg1 = 0 ; - Dali::WidgetView::WidgetView *result = 0 ; - - arg1 = (Dali::WidgetView::WidgetView *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetView::WidgetView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::WidgetView::WidgetView *)new Dali::WidgetView::WidgetView((Dali::WidgetView::WidgetView const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetView_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; - Dali::WidgetView::WidgetView *arg2 = 0 ; - Dali::WidgetView::WidgetView *result = 0 ; - - arg1 = (Dali::WidgetView::WidgetView *)jarg1; - arg2 = (Dali::WidgetView::WidgetView *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetView::WidgetView const & type is null", 0); - return 0; - } - { - try { - result = (Dali::WidgetView::WidgetView *) &(arg1)->operator =((Dali::WidgetView::WidgetView const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetView(void * jarg1) { - Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; - - arg1 = (Dali::WidgetView::WidgetView *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WidgetView_PauseWidget(void * jarg1) { - unsigned int jresult ; - Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; - bool result; - - arg1 = (Dali::WidgetView::WidgetView *)jarg1; - { - try { - result = (bool)(arg1)->PauseWidget(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WidgetView_ResumeWidget(void * jarg1) { - unsigned int jresult ; - Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; - bool result; - - arg1 = (Dali::WidgetView::WidgetView *)jarg1; - { - try { - result = (bool)(arg1)->ResumeWidget(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WidgetView_CancelTouchEvent(void * jarg1) { - unsigned int jresult ; - Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; - bool result; - - arg1 = (Dali::WidgetView::WidgetView *)jarg1; - { - try { - result = (bool)(arg1)->CancelTouchEvent(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetView_ActivateFaultedWidget(void * jarg1) { - Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; - - arg1 = (Dali::WidgetView::WidgetView *)jarg1; - { - try { - (arg1)->ActivateFaultedWidget(); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WidgetView_TerminateWidget(void * jarg1) { - unsigned int jresult; - Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; - bool result; - - arg1 = (Dali::WidgetView::WidgetView *)jarg1; - { - try { - result = (bool)(arg1)->TerminateWidget(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetView_WidgetAddedSignal(void * jarg1) { - void * jresult ; - Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; - Dali::WidgetView::WidgetView::WidgetViewSignalType *result = 0 ; - - arg1 = (Dali::WidgetView::WidgetView *)jarg1; - { - try { - result = (Dali::WidgetView::WidgetView::WidgetViewSignalType *) &(arg1)->WidgetAddedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetView_WidgetDeletedSignal(void * jarg1) { - void * jresult ; - Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; - Dali::WidgetView::WidgetView::WidgetViewSignalType *result = 0 ; - - arg1 = (Dali::WidgetView::WidgetView *)jarg1; - { - try { - result = (Dali::WidgetView::WidgetView::WidgetViewSignalType *) &(arg1)->WidgetDeletedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetView_WidgetCreationAbortedSignal(void * jarg1) { - void * jresult ; - Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; - Dali::WidgetView::WidgetView::WidgetViewSignalType *result = 0 ; - - arg1 = (Dali::WidgetView::WidgetView *)jarg1; - { - try { - result = (Dali::WidgetView::WidgetView::WidgetViewSignalType *) &(arg1)->WidgetCreationAbortedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetView_WidgetContentUpdatedSignal(void * jarg1) { - void * jresult ; - Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; - Dali::WidgetView::WidgetView::WidgetViewSignalType *result = 0 ; - - arg1 = (Dali::WidgetView::WidgetView *)jarg1; - { - try { - result = (Dali::WidgetView::WidgetView::WidgetViewSignalType *) &(arg1)->WidgetContentUpdatedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetView_WidgetUpdatePeriodChangedSignal(void * jarg1) { - void * jresult ; - Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; - Dali::WidgetView::WidgetView::WidgetViewSignalType *result = 0 ; - - arg1 = (Dali::WidgetView::WidgetView *)jarg1; - { - try { - result = (Dali::WidgetView::WidgetView::WidgetViewSignalType *) &(arg1)->WidgetUpdatePeriodChangedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetView_WidgetFaultedSignal(void * jarg1) { - void * jresult ; - Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; - Dali::WidgetView::WidgetView::WidgetViewSignalType *result = 0 ; - - arg1 = (Dali::WidgetView::WidgetView *)jarg1; - { - try { - result = (Dali::WidgetView::WidgetView::WidgetViewSignalType *) &(arg1)->WidgetFaultedSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - - -//For widget view signal -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WidgetViewSignal_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void (Dali::WidgetView::WidgetView) > *arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__Empty((Dali::Signal< void (Dali::WidgetView::WidgetView) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WidgetViewSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::WidgetView::WidgetView) > *arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WidgetView::WidgetView) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetViewSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::WidgetView::WidgetView) > *arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *) 0 ; - void (*arg2)(Dali::WidgetView::WidgetView) = (void (*)(Dali::WidgetView::WidgetView)) 0 ; - - arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *)jarg1; - arg2 = (void (*)(Dali::WidgetView::WidgetView))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetViewSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::WidgetView::WidgetView) > *arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *) 0 ; - void (*arg2)(Dali::WidgetView::WidgetView) = (void (*)(Dali::WidgetView::WidgetView)) 0 ; - - arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *)jarg1; - arg2 = (void (*)(Dali::WidgetView::WidgetView))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetViewSignal_Emit(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::WidgetView::WidgetView) > *arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *) 0 ; - Dali::WidgetView::WidgetView arg2 ; - Dali::WidgetView::WidgetView *argp2 ; - - arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *)jarg1; - argp2 = (Dali::WidgetView::WidgetView *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::WidgetView::WidgetView", 0); - return ; - } - arg2 = *argp2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__Emit(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetViewSignal() { - void * jresult ; - Dali::Signal< void (Dali::WidgetView::WidgetView) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *)new Dali::Signal< void (Dali::WidgetView::WidgetView) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetViewSignal(void * jarg1) { - Dali::Signal< void (Dali::WidgetView::WidgetView) > *arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - -#ifdef __cplusplus -} -#endif - diff --git a/dali-csharp-binder/src/window-data-wrap.cpp b/dali-csharp-binder/src/window-data-wrap.cpp deleted file mode 100644 index 09bb0b43..00000000 --- a/dali-csharp-binder/src/window-data-wrap.cpp +++ /dev/null @@ -1,202 +0,0 @@ -/* - * Copyright (c) 2023 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. - * - */ - -#include - -#include "common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_WindowData() -{ - void* nuiResult; - Dali::WindowData* result = 0; - - { - try - { - result = (Dali::WindowData*)new Dali::WindowData(); - } - CALL_CATCH_EXCEPTION(0); - } - - nuiResult = (void*)result; - return nuiResult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowData(void* nuiWindowData) -{ - Dali::WindowData* handle = (Dali::WindowData*)0; - - handle = (Dali::WindowData*)nuiWindowData; - { - try - { - delete handle; - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowData_SetPositionSize(void* nuiWindowData, void* nuiPositionSize) -{ - Dali::WindowData* pWindowData; - Dali::Rect* rect = 0; - - pWindowData = (Dali::WindowData*)nuiWindowData; - if(!pWindowData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::WindowData", 0); - return; - } - - rect = (Dali::Rect*)nuiPositionSize; - if(!rect) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); - return; - } - { - try - { - pWindowData->SetPositionSize(*rect); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_WindowData_GetPositionSize(void* nuiWindowData) -{ - void* nuiResult; - Dali::WindowData* pWindowData; - Dali::Rect result; - - pWindowData = (Dali::WindowData*)nuiWindowData; - if(!pWindowData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::WindowData", 0); - return nullptr; - } - - { - try - { - result = pWindowData->GetPositionSize(); - } - CALL_CATCH_EXCEPTION(0); - } - - nuiResult = new Dali::Rect((const Dali::Rect&)result); - return nuiResult; -} - -// -- -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowData_SetWindowType(void* nuiWindowData, int nuiWindowType) -{ - Dali::WindowData* pWindowData; - Dali::WindowType windowType; - - pWindowData = (Dali::WindowData*)nuiWindowData; - if(!pWindowData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::WindowData", 0); - return; - } - - windowType = (Dali::WindowType)nuiWindowType; - { - try - { - pWindowData->SetWindowType(windowType); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WindowData_GetWindowType(void* nuiWindowData) -{ - int nuiResult; - Dali::WindowData* pWindowData; - Dali::WindowType result; - - pWindowData = (Dali::WindowData*)nuiWindowData; - if(!pWindowData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::WindowData", 0); - return 0; - } - - { - try - { - result = (Dali::WindowType)pWindowData->GetWindowType(); - } - CALL_CATCH_EXCEPTION(0); - } - - nuiResult = (int)result; - return nuiResult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowData_SetTransparency(void* nuiWindowData, bool nuiTransparency) -{ - Dali::WindowData* pWindowData; - - pWindowData = (Dali::WindowData*)nuiWindowData; - if(!pWindowData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::WindowData", 0); - return; - } - - { - try - { - pWindowData->SetTransparency(nuiTransparency); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WindowData_GetTransparency(void* nuiWindowData) -{ - Dali::WindowData* pWindowData; - bool result; - - pWindowData = (Dali::WindowData*)nuiWindowData; - if(!pWindowData) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::WindowData", 0); - return 0; - } - - { - try - { - result = (bool)pWindowData->GetTransparency(); - } - CALL_CATCH_EXCEPTION(0); - } - - return result; -} - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/src/window-wrap.cpp b/dali-csharp-binder/src/window-wrap.cpp deleted file mode 100644 index 8f7b5902..00000000 --- a/dali-csharp-binder/src/window-wrap.cpp +++ /dev/null @@ -1,3829 +0,0 @@ -/* - * Copyright (c) 2023 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. - * - */ - -// EXTERNAL INCLUDES -#include -#include -#include -#include -#include - -// INTERNAL INCLUDES -#include "common.h" - -/* Callback for returning strings to C# without leaking memory */ -typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); -extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback; - - - -SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Window, bool) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Window, bool) > const *self){ -return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Window, bool) > *self,void (*func)(Dali::Window, bool)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Window, bool) > *self,void (*func)(Dali::Window, bool)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Window, bool) > *self,Dali::Window arg, bool focusIn){ - self->Emit( arg, focusIn ); -} - -/*ResizeSignal*/ -SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Empty(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *self){ -return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Connect(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *self,void (*func)(Dali::Window, Dali::Window::WindowSize)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Disconnect(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *self,void (*func)(Dali::Window, Dali::Window::WindowSize)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Emit(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *self, Dali::Window arg, Dali::Window::WindowSize size){ - self->Emit( arg, size ); -} - -//Transition effect -SWIGINTERN bool Dali_Signal_Window_Transition_Effect_Event_Signal_Empty(Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Window_Transition_Effect_Event_Signal_GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > const *self){ -return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Window_Transition_Effect_Event_Signal_Connect(Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *self, void (*func)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Window_Transition_Effect_Event_Signal_Disconnect(Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *self,void (*func)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Window_Transition_Effect_Event_Signal_Emit(Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *self,Dali::Window arg, Dali::WindowEffectState state, Dali::WindowEffectType type){ - self->Emit( arg, state, type ); -} - -/* Moved signal */ -SWIGINTERN bool Dali_Signal_Window_Moved_Signal_Empty(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Window_Moved_Signal_GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *self){ -return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Window_Moved_Signal_Connect(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *self, void (*func)(Dali::Window, Dali::Window::WindowPosition)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Window_Moved_Signal_Disconnect(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *self,void (*func)(Dali::Window, Dali::Window::WindowPosition)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Window_Moved_Signal_Emit(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *self,Dali::Window window, Dali::Window::WindowPosition position){ - self->Emit( window, position ); -} - -//Orientation Changed -SWIGINTERN bool Dali_Signal_Window_Orientation_Changed_Signal_Empty(Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Window_Orientation_Changed_Signal_GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > const *self){ -return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Window_Orientation_Changed_Signal_Connect(Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *self, void (*func)(Dali::Window, Dali::WindowOrientation)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Window_Orientation_Changed_Signal_Disconnect(Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *self, void (*func)(Dali::Window, Dali::WindowOrientation)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Window_Orientation_Changed_Signal_Emit(Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *self, Dali::Window arg, Dali::WindowOrientation orientation){ - self->Emit( arg, orientation ); -} - -//input -SWIGINTERN bool Dali_Signal_Window_MouseInOutEvent_Signal_Empty(Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Window_MouseInOutEvent_Signal_GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > const *self){ -return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Window_MouseInOutEvent_Signal_Connect(Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *self, void (*func)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Window_MouseInOutEvent_Signal_Disconnect(Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *self, void (*func)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Window_MouseInOutEvent_Signal_Emit(Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *self, Dali::Window arg, Dali::DevelWindow::MouseInOutEvent const &mouseInOutEvent){ - self->Emit( arg, mouseInOutEvent ); -} - -/* Move Completed signal */ -SWIGINTERN bool Dali_Signal_Window_Move_Completed_Signal_Empty(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Window_Move_Completed_Signal_GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *self){ -return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Window_Move_Completed_Signal_Connect(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *self, void (*func)(Dali::Window, Dali::Window::WindowPosition)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Window_Move_Completed_Signal_Disconnect(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *self,void (*func)(Dali::Window, Dali::Window::WindowPosition)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Window_Move_Completed_Signal_Emit(Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *self,Dali::Window window, Dali::Window::WindowPosition position){ - self->Emit( window, position ); -} - -/* Resize Completed signal */ -SWIGINTERN bool Dali_Signal_Window_Resize_Completed_Signal_Empty(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *self){ - return self->Empty(); -} -SWIGINTERN std::size_t Dali_Signal_Window_Resize_Completed_Signal_GetConnectionCount(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *self){ -return self->GetConnectionCount(); -} -SWIGINTERN void Dali_Signal_Window_Resize_Completed_Signal_Connect(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *self, void (*func)(Dali::Window, Dali::Window::WindowSize)){ - self->Connect( func ); -} -SWIGINTERN void Dali_Signal_Window_Resize_Completed_Signal_Disconnect(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *self,void (*func)(Dali::Window, Dali::Window::WindowSize)){ - self->Disconnect( func ); -} -SWIGINTERN void Dali_Signal_Window_Resize_Completed_Signal_Emit(Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *self,Dali::Window window, Dali::Window::WindowSize size){ - self->Emit( window, size ); -} - - -#ifdef __cplusplus -extern "C" { -#endif - -/*Window binding*/ -SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) { - return (Dali::BaseHandle *)jarg1; -} - -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; - - argp1 = (Dali::PositionSize *)jarg1; - if (!argp1) - { - arg1 = Dali::PositionSize(0, 0, 0, 0); - } - else - { - arg1 = *argp1; - } - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - arg3 = jarg3 ? true : false; - { - try { - result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Window((const Dali::Window &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) { - void * jresult ; - Dali::PositionSize arg1 ; - std::string *arg2 = 0 ; - 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; - { - try { - result = Dali::Window::New(arg1,(std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Window((const Dali::Window &)result); - - //argout typemap for const std::string& - - return jresult; -} - - -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); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Window((const Dali::Window &)result); - - 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 ; - std::string *arg3 = 0 ; - 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; - { - try { - result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Window((const Dali::Window &)result); - - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() { - void * jresult ; - Dali::Window *result = 0 ; - - { - try { - result = (Dali::Window *)new Dali::Window(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) { - Dali::Window *arg1 = (Dali::Window *) 0 ; - - arg1 = (Dali::Window *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) { - void * jresult ; - Dali::Window *arg1 = 0 ; - Dali::Window *result = 0 ; - - arg1 = (Dali::Window *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) { - void * jresult ; - Dali::Window *arg1 = (Dali::Window *) 0 ; - Dali::Window *arg2 = 0 ; - Dali::Window *result = 0 ; - - arg1 = (Dali::Window *)jarg1; - arg2 = (Dali::Window *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) { - Dali::Window *arg1 = (Dali::Window *) 0 ; - std::string arg2 ; - std::string arg3 ; - - arg1 = (Dali::Window *)jarg1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - (&arg2)->assign(jarg2); - if (!jarg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return ; - } - (&arg3)->assign(jarg3); - { - try { - (arg1)->SetClass(arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) { - Dali::Window *arg1 = (Dali::Window *) 0 ; - - arg1 = (Dali::Window *)jarg1; - { - try { - (arg1)->Raise(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) { - Dali::Window *arg1 = (Dali::Window *) 0 ; - - arg1 = (Dali::Window *)jarg1; - { - try { - (arg1)->Lower(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) { - Dali::Window *arg1 = (Dali::Window *) 0 ; - - arg1 = (Dali::Window *)jarg1; - { - try { - (arg1)->Activate(); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Maximize(void * winHandle, bool maximize) { - Dali::Window *window = (Dali::Window *) 0 ; - - window = (Dali::Window *)winHandle; - { - try { - Dali::DevelWindow::Maximize(*window, maximize); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_IsMaximized(void * winHandle) { - Dali::Window *window = (Dali::Window *) 0 ; - bool isMaximized = false; - - window = (Dali::Window *)winHandle; - { - try { - isMaximized = Dali::DevelWindow::IsMaximized(*window); - } CALL_CATCH_EXCEPTION(false); - } - return isMaximized; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Set_Maximum_Size(void * winHandle, void * size) { - Dali::Window *window = (Dali::Window *) 0 ; - Dali::Window::WindowSize *winSize; - Dali::Window::WindowSize maximumSize; - - window = (Dali::Window *)winHandle; - - winSize = (Dali::Window::WindowSize *)size; - if (!winSize) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowSize", 0); - return ; - } - maximumSize = *winSize; - - { - try { - Dali::DevelWindow::SetMaximumSize(*window, maximumSize); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Minimize(void * winHandle, bool minimize) { - Dali::Window *window = (Dali::Window *) 0 ; - - window = (Dali::Window *)winHandle; - { - try { - Dali::DevelWindow::Minimize(*window, minimize); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_IsMinimized(void * winHandle) { - Dali::Window *window = (Dali::Window *) 0 ; - bool isMinimized = false; - - window = (Dali::Window *)winHandle; - { - try { - isMinimized = Dali::DevelWindow::IsMinimized(*window); - } CALL_CATCH_EXCEPTION(false); - } - return isMinimized; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Set_Minimum_Size(void * winHandle, void * size) { - Dali::Window *window = (Dali::Window *) 0 ; - Dali::Window::WindowSize *winSize; - Dali::Window::WindowSize minimumSize; - - window = (Dali::Window *)winHandle; - - winSize = (Dali::Window::WindowSize *)size; - if (!winSize) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowSize", 0); - return ; - } - minimumSize = *winSize; - - window = (Dali::Window *)winHandle; - { - try { - Dali::DevelWindow::SetMimimumSize(*window, minimumSize); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) { - Dali::Window *arg1 = (Dali::Window *) 0 ; - Dali::WindowOrientation arg2 ; - - arg1 = (Dali::Window *)jarg1; - arg2 = (Dali::WindowOrientation)jarg2; - { - try { - (arg1)->AddAvailableOrientation(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) { - Dali::Window *arg1 = (Dali::Window *) 0 ; - Dali::WindowOrientation arg2 ; - - arg1 = (Dali::Window *)jarg1; - arg2 = (Dali::WindowOrientation)jarg2; - { - try { - (arg1)->RemoveAvailableOrientation(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) { - Dali::Window *arg1 = (Dali::Window *) 0 ; - Dali::WindowOrientation arg2 ; - - arg1 = (Dali::Window *)jarg1; - arg2 = (Dali::WindowOrientation)jarg2; - { - try { - (arg1)->SetPreferredOrientation(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) { - int jresult ; - Dali::Window *arg1 = (Dali::Window *) 0 ; - Dali::WindowOrientation result; - - arg1 = (Dali::Window *)jarg1; - { - try { - result = (Dali::WindowOrientation)(arg1)->GetPreferredOrientation(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetCurrentOrientation(void * jarg1) { - int jresult ; - Dali::WindowOrientation result; - Dali::Window* window = (Dali::Window*)jarg1; - if (!window) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - { - try { - result = Dali::DevelWindow::GetCurrentOrientation(*window); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetAvailableOrientations(void * jarg1, void* jarg2, int jarg3) { - Dali::Window* window = (Dali::Window*)jarg1; - if(!window) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return; - } - Dali::Property::Array *arg2 = (static_cast(jarg2)); - unsigned int count = static_cast(jarg3); - - Dali::Vector< Dali::WindowOrientation> orientations; - orientations.Resize( count ); - for(Dali::Property::Array::SizeType i = 0; i < count; ++i) - { - int angle = arg2->GetElementAt(i).Get(); - orientations[i] = static_cast< Dali::WindowOrientation >(angle); - } - { - try { - Dali::DevelWindow::SetAvailableOrientations(*window, orientations); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) { - void * jresult ; - Dali::Window *arg1 = (Dali::Window *) 0 ; - Dali::Any result; - - arg1 = (Dali::Window *)jarg1; - { - try { - result = ((Dali::Window const *)arg1)->GetNativeHandle(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Any((const Dali::Any &)result); - return jresult; -} - -/*window-devel binding*/ - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) { - void * jresult ; - Dali::Window arg1 ; - Dali::Window *argp1 ; - Dali::Window::FocusChangeSignalType *result = 0 ; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - arg1 = *argp1; - { - try { - result = (Dali::Window::FocusChangeSignalType*)&arg1.FocusChangeSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) { - Dali::Window arg1 ; - bool arg2 ; - Dali::Window *argp1 ; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - arg1 = *argp1; - arg2 = jarg2 ? true : false; - { - try { - arg1.SetAcceptFocus(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) { - unsigned int jresult ; - Dali::Window arg1 ; - Dali::Window *argp1 ; - bool result; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - arg1 = *argp1; - { - try { - result = (bool)arg1.IsFocusAcceptable(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) { - Dali::Window arg1 ; - Dali::Window *argp1 ; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - arg1 = *argp1; - { - try { - arg1.Show(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) { - Dali::Window arg1 ; - Dali::Window *argp1 ; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - arg1 = *argp1; - { - try { - arg1.Hide(); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) { - unsigned int jresult ; - Dali::Window arg1 ; - Dali::Window *argp1 ; - bool result; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - arg1 = *argp1; - { - try { - result = (bool)arg1.IsVisible(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHintCount(void * jarg1) { - unsigned int jresult ; - Dali::Window arg1 ; - Dali::Window *argp1 ; - unsigned int result; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - arg1 = *argp1; - { - try { - result = (unsigned int)arg1.GetSupportedAuxiliaryHintCount(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHint(void * jarg1, unsigned int jarg2) { - char * jresult ; - Dali::Window arg1 ; - unsigned int arg2 ; - Dali::Window *argp1 ; - std::string result; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - arg1 = *argp1; - arg2 = (unsigned int)jarg2; - { - try { - result = arg1.GetSupportedAuxiliaryHint(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback((&result)->c_str()); - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AddAuxiliaryHint(void * jarg1, char * jarg2, char * jarg3) { - unsigned int jresult ; - Dali::Window arg1 ; - std::string *arg2 = 0 ; - std::string *arg3 = 0 ; - Dali::Window *argp1 ; - unsigned int result; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 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; - { - try { - result = (unsigned int)arg1.AddAuxiliaryHint((std::string const &)*arg2,(std::string const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RemoveAuxiliaryHint(void * jarg1, unsigned int jarg2) { - unsigned int jresult ; - Dali::Window arg1 ; - unsigned int arg2 ; - Dali::Window *argp1 ; - bool result; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - arg1 = *argp1; - arg2 = (unsigned int)jarg2; - { - try { - result = (bool)arg1.RemoveAuxiliaryHint(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetAuxiliaryHintValue(void * jarg1, unsigned int jarg2, char * jarg3) { - unsigned int jresult ; - Dali::Window arg1 ; - unsigned int arg2 ; - std::string *arg3 = 0 ; - Dali::Window *argp1 ; - bool result; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - arg1 = *argp1; - arg2 = (unsigned int)jarg2; - if (!jarg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg3_str(jarg3); - arg3 = &arg3_str; - { - try { - result = (bool)arg1.SetAuxiliaryHintValue(arg2,(std::string const &)*arg3); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintValue(void * jarg1, unsigned int jarg2) { - char * jresult ; - Dali::Window arg1 ; - unsigned int arg2 ; - Dali::Window *argp1 ; - std::string result; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - arg1 = *argp1; - arg2 = (unsigned int)jarg2; - { - try { - result = arg1.GetAuxiliaryHintValue(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = SWIG_csharp_string_callback((&result)->c_str()); - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintId(void * jarg1, char * jarg2) { - unsigned int jresult ; - Dali::Window arg1 ; - std::string *arg2 = 0 ; - Dali::Window *argp1 ; - unsigned int result; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - arg1 = *argp1; - if (!jarg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); - return 0; - } - std::string arg2_str(jarg2); - arg2 = &arg2_str; - { - try { - result = (unsigned int)arg1.GetAuxiliaryHintId((std::string const &)*arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - - //argout typemap for const std::string& - - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetInputRegion(void * jarg1, void * jarg2) { - Dali::Window arg1 ; - Dali::Rect< int > *arg2 = 0 ; - Dali::Window *argp1 ; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - arg1 = *argp1; - arg2 = (Dali::Rect< int > *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); - return ; - } - { - try { - arg1.SetInputRegion((Dali::Rect< int > const &)*arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetType(void * jarg1, int jarg2) { - Dali::Window arg1 ; - Dali::WindowType arg2 ; - Dali::Window *argp1 ; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - arg1 = *argp1; - arg2 = (Dali::WindowType)jarg2; - { - try { - arg1.SetType(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetType(void * jarg1) { - int jresult ; - Dali::Window arg1 ; - Dali::Window *argp1 ; - Dali::WindowType result; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - arg1 = *argp1; - { - try { - result = (Dali::WindowType)arg1.GetType(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetNotificationLevel(void * jarg1, int jarg2) { - unsigned int jresult ; - Dali::Window arg1 ; - Dali::WindowNotificationLevel arg2 ; - Dali::Window *argp1 ; - int result; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - arg1 = *argp1; - arg2 = (Dali::WindowNotificationLevel)jarg2; - { - try { - result = (int)arg1.SetNotificationLevel(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetNotificationLevel(void * jarg1) { - int jresult ; - Dali::Window arg1 ; - Dali::Window *argp1 ; - Dali::WindowNotificationLevel result; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - arg1 = *argp1; - { - try { - result = (Dali::WindowNotificationLevel)arg1.GetNotificationLevel(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetOpaqueState(void * jarg1, unsigned int jarg2) { - Dali::Window arg1 ; - bool arg2 ; - Dali::Window *argp1 ; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - arg1 = *argp1; - arg2 = jarg2 ? true : false; - { - try { - arg1.SetOpaqueState(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsOpaqueState(void * jarg1) { - unsigned int jresult ; - Dali::Window arg1 ; - Dali::Window *argp1 ; - bool result; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - arg1 = *argp1; - { - try { - result = (bool)arg1.IsOpaqueState(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetScreenOffMode(void * jarg1, int jarg2) { - unsigned int jresult ; - Dali::Window arg1 ; - Dali::WindowScreenOffMode arg2 ; - Dali::Window *argp1 ; - int result; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - arg1 = *argp1; - arg2 = (Dali::WindowScreenOffMode)jarg2; - { - try { - result = (int)arg1.SetScreenOffMode(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetScreenOffMode(void * jarg1) { - int jresult ; - Dali::Window arg1 ; - Dali::Window *argp1 ; - Dali::WindowScreenOffMode result; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - arg1 = *argp1; - { - try { - result = (Dali::WindowScreenOffMode)arg1.GetScreenOffMode(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetBrightness(void * jarg1, int jarg2) { - unsigned int jresult ; - Dali::Window arg1 ; - int arg2 ; - Dali::Window *argp1 ; - int result; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - arg1 = *argp1; - arg2 = (int)jarg2; - { - try { - result = (int)arg1.SetBrightness(arg2); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetBrightness(void * jarg1) { - int jresult ; - Dali::Window arg1 ; - Dali::Window *argp1 ; - int result; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - arg1 = *argp1; - { - try { - result = (int)arg1.GetBrightness(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void (Dali::Window, bool) > *arg1 = (Dali::Signal< void (Dali::Window, bool) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Window, bool) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Window, bool) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Window, bool) > *arg1 = (Dali::Signal< void (Dali::Window, bool) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Window, bool) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Window, bool) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Window, bool) > *arg1 = (Dali::Signal< void (Dali::Window, bool) > *) 0 ; - void (*arg2)(Dali::Window, bool) = (void (*)(Dali::Window, bool)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Window, bool) > *)jarg1; - arg2 = (void (*)(Dali::Window, bool))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Window, bool) > *arg1 = (Dali::Signal< void (Dali::Window, bool) > *) 0 ; - void (*arg2)(Dali::Window, bool) = (void (*)(Dali::Window, bool)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Window, bool) > *)jarg1; - arg2 = (void (*)(Dali::Window, bool))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, void* jarg2, unsigned int jarg3) { - Dali::Signal< void (Dali::Window, bool) > *arg1 = (Dali::Signal< void (Dali::Window, bool) > *)jarg1; - Dali::Window* arg2 = (Dali::Window*)jarg2; - bool arg3 = jarg3 ? true : false;; - - if (arg1 == nullptr || arg2 == nullptr) { - DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr"); - return; - } - - { - try { - Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,*arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() { - void * jresult ; - Dali::Signal< void (Dali::Window, bool) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Window, bool) > *)new Dali::Signal< void (Dali::Window, bool) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) { - Dali::Signal< void (Dali::Window, bool) > *arg1 = (Dali::Signal< void (Dali::Window, bool) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Window, bool) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_ResizeSignal(void * jarg1) { - void * jresult ; - Dali::Window arg1 ; - Dali::Window *argp1 ; - Dali::Window::ResizeSignalType *result = 0 ; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - arg1 = *argp1; - { - try { - result = (Dali::Window::ResizeSignalType *) &arg1.ResizeSignal(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -/*ResizedSignal binding*/ -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResizeSignal_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Empty((Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResizeSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)jarg1; - { - try { - result = Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResizeSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; - void (*arg2)(Dali::Window, Dali::Window::WindowSize) = (void (*)(Dali::Window, Dali::Window::WindowSize)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)jarg1; - arg2 = (void (*)(Dali::Window, Dali::Window::WindowSize))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResizeSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; - void (*arg2)(Dali::Window, Dali::Window::WindowSize) = (void (*)(Dali::Window, Dali::Window::WindowSize)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)jarg1; - arg2 = (void (*)(Dali::Window, Dali::Window::WindowSize))jarg2; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResizeSignal_Emit(void * jarg1, void* jarg2, void * jarg3) { - Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; - Dali::Window* arg2 = (Dali::Window*)jarg2; - Dali::Window::WindowSize arg3 ; - Dali::Window::WindowSize *argp3 ; - - arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)jarg1; - if (arg1 == nullptr || arg2 == nullptr) { - DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr"); - return; - } - - argp3 = (Dali::Window::WindowSize *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowSize", 0); - return ; - } - arg3 = *argp3; - { - try { - Dali_Signal_Sl_void_Sp_Dali_Window_WindowSize_SP__Sg__Emit(arg1,*arg2,arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResizeSignal() { - void * jresult ; - Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)new Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResizeSignal(void * jarg1) { - Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetSize(void * jarg1, void * jarg2) { - Dali::Window arg1 ; - Dali::Window::WindowSize arg2 ; - Dali::Window *argp1 ; - Dali::Window::WindowSize *argp2 ; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - arg1 = *argp1; - argp2 = (Dali::Window::WindowSize *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window::WindowSize", 0); - return ; - } - arg2 = *argp2; - { - try { - arg1.SetSize(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetSize(void * jarg1) { - void * jresult ; - Dali::Window arg1 ; - Dali::Window *argp1 ; - Dali::Window::WindowSize result; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - arg1 = *argp1; - { - try { - result = arg1.GetSize(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Window::WindowSize((const Dali::Window::WindowSize &)result); - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPosition(void * handle, void * position) { - Dali::Window *pWindow; - Dali::Window window; - Dali::Window::WindowPosition *pPosition; - Dali::Window::WindowPosition windowPosition; - - pWindow = (Dali::Window *)handle; - if (!pWindow) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - window = *pWindow; - - pPosition = (Dali::Window::WindowPosition *)position; - if (!pPosition) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::WindowPosition", 0); - return ; - } - windowPosition = *pPosition; - - { - try { - window.SetPosition(windowPosition); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetPosition(void * handle) { - Dali::Window *pWindow ; - Dali::Window window ; - Dali::Window::WindowPosition windowPosition; - Dali::Window::WindowPosition result; - void * jresult ; - - pWindow = (Dali::Window *)handle; - if (!pWindow) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - window = *pWindow; - { - try { - windowPosition = window.GetPosition(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Window::WindowPosition((const Dali::Window::WindowPosition &)windowPosition); - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPositionSize(void* jarg1, void* jarg2) -{ - Dali::Window* window = (Dali::Window*)jarg1; - if (!window) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - - Dali::Rect* positionSize = (Dali::Rect*)jarg2; - if (!positionSize) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); - return ; - } - { - try { - Dali::DevelWindow::SetPositionSize(*window, *positionSize); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetLayout(void* handle, unsigned int numCols, unsigned int numRows, unsigned int column, unsigned int row, unsigned int colSpan, unsigned int rowSpan) -{ - Dali::Window *pWindow; - Dali::Window window; - - pWindow = (Dali::Window *)handle; - if (!pWindow) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - window = *pWindow; - - { - try { - window.SetLayout(numCols, numRows, column, row, colSpan, rowSpan); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetTransparency(void * jarg1, unsigned int jarg2) { - Dali::Window arg1 ; - bool arg2 ; - Dali::Window *argp1 ; - - argp1 = (Dali::Window *)jarg1; - if (!argp1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - arg1 = *argp1; - arg2 = jarg2 ? true : false; - { - try { - arg1.SetTransparency(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_FeedKey_Default_Window(void * event) { - Dali::KeyEvent *keyEvent = 0 ; - - keyEvent = (Dali::KeyEvent *)event; - if (!keyEvent) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent & type is null", 0); - return ; - } - { - try { - Dali::Adaptor::Get().FeedKeyEvent(*keyEvent); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_FeedKey(void * window, void * event) { - Dali::Window* win = (Dali::Window*)window; - if (!win) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - - Dali::KeyEvent *keyEvent = 0 ; - keyEvent = (Dali::KeyEvent *)event; - if (!keyEvent) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent & type is null", 0); - return ; - } - { - try { - Dali::DevelWindow::FeedKeyEvent(*win, *keyEvent); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_FeedTouch(void * window, void * event, int timeStamp) { - Dali::Window* win = (Dali::Window*)window; - if (!win) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - - Dali::TouchPoint *touchPoint = 0 ; - touchPoint = (Dali::TouchPoint *)event; - if (!touchPoint) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint & type is null", 0); - return ; - } - { - try { - Dali::DevelWindow::FeedTouchPoint(*win, *touchPoint, timeStamp); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_FeedWheel(void * window, void * event) { - Dali::Window* win = (Dali::Window*)window; - if (!win) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - - Dali::WheelEvent *wheelEvent = 0 ; - wheelEvent = (Dali::WheelEvent *)event; - if (!wheelEvent) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent & type is null", 0); - return ; - } - { - try { - Dali::DevelWindow::FeedWheelEvent(*win, *wheelEvent); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_FeedHover(void * window, void * touchPoint) { - Dali::Window* win = (Dali::Window*)window; - if (!win) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - - Dali::TouchPoint *aTouchPoint = 0 ; - aTouchPoint = (Dali::TouchPoint *)touchPoint; - if (!aTouchPoint) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint & type is null", 0); - return ; - } - { - try { - Dali::DevelWindow::FeedHoverEvent(*win, *aTouchPoint); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Adaptor_RenderOnce(void * /* jarg1 */) { - try { - Dali::Adaptor::Get().RenderOnce(); - } CALL_CATCH_EXCEPTION(); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Add(void * jarg1, void * jarg2) { - Dali::Window *arg1 = (Dali::Window *) 0 ; - Dali::Actor arg2 ; - Dali::Actor *argp2 ; - - arg1 = (Dali::Window *)jarg1; - argp2 = (Dali::Actor *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->Add(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Remove(void * jarg1, void * jarg2) { - Dali::Window *arg1 = (Dali::Window *) 0 ; - Dali::Actor *arg2 = 0 ; - - arg1 = (Dali::Window *)jarg1; - arg2 = (Dali::Actor *)jarg2; - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0); - return ; - } - { - try { - (arg1)->Remove(*arg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetBackgroundColor(void * jarg1, void * jarg2) { - Dali::Window *arg1 = (Dali::Window *) 0 ; - Dali::Vector4 arg2 ; - Dali::Vector4 *argp2 ; - - arg1 = (Dali::Window *)jarg1; - argp2 = (Dali::Vector4 *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0); - return ; - } - arg2 = *argp2; - { - try { - (arg1)->SetBackgroundColor(arg2); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetBackgroundColor(void * jarg1) { - void * jresult ; - Dali::Window *arg1 = (Dali::Window *) 0 ; - Dali::Vector4 result; - - arg1 = (Dali::Window *)jarg1; - { - try { - result = ((Dali::Window const *)arg1)->GetBackgroundColor(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Vector4((const Dali::Vector4 &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetRootLayer(void * csWindow) { - void * jresult ; - Dali::Window *window = (Dali::Window *) 0 ; - Dali::Layer result; - - window = (Dali::Window *)csWindow; - { - try { - result = ((Dali::Window const *)window)->GetRootLayer(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Layer((const Dali::Layer &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetOverlayLayer(void * csWindow) { - void * jresult ; - Dali::Window *window = (Dali::Window *) 0 ; - Dali::Layer result; - - window = (Dali::Window *)csWindow; - { - try { - result = ((Dali::Window *)window)->GetOverlayLayer(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = new Dali::Layer((const Dali::Layer &)result); - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_KeyEventSignal(void * jarg1) { - void * jresult ; - Dali::Window *arg1 = (Dali::Window *) 0 ; - Dali::Window::KeyEventSignalType *result = 0 ; - - arg1 = (Dali::Window *)jarg1; - { - try { - result = (Dali::Window::KeyEventSignalType *) &(arg1->KeyEventSignal()); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_InterceptKeyEventSignal(void * winHandle) { - void * jresult ; - Dali::Window *window = (Dali::Window *) 0 ; - Dali::DevelWindow::InterceptKeyEventSignalType *result = 0 ; - - window = (Dali::Window *)winHandle; - if (!window) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - { - try { - result = (Dali::DevelWindow::InterceptKeyEventSignalType *) &(Dali::DevelWindow::InterceptKeyEventSignal(*window)); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_TouchSignal(void * jarg1) { - void * jresult ; - Dali::Window *arg1 = (Dali::Window *) 0 ; - Dali::Window::TouchEventSignalType *result = 0 ; - - arg1 = (Dali::Window *)jarg1; - { - try { - result = (Dali::Window::TouchEventSignalType *) &(arg1->TouchedSignal()); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetParent(void* child, void* parent) -{ - Dali::Window* childWindow = (Dali::Window*)child; - if (!childWindow) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - - Dali::Window* parentWindow = (Dali::Window*)parent; - if (!parentWindow) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - { - try { - Dali::DevelWindow::SetParent(*childWindow, *parentWindow); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetParent_With_Stack(void* child, void* parent, bool belowParent) -{ - Dali::Window* childWindow = (Dali::Window*)child; - if (!childWindow) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - - Dali::Window* parentWindow = (Dali::Window*)parent; - if (!parentWindow) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - { - try { - Dali::DevelWindow::SetParent(*childWindow, *parentWindow, belowParent); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Unparent(void* jarg1) -{ - Dali::Window* window = (Dali::Window*)jarg1; - if (!window) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - { - try { - Dali::DevelWindow::Unparent(*window); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetParent(void* jarg1) -{ - void * jresult ; - Dali::Window* window = (Dali::Window*)jarg1; - Dali::Window result; - if (!window) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - { - try { - result = Dali::DevelWindow::GetParent(*window); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Window((const Dali::Window &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetWindow(void * jarg1) { - void * jresult ; - Dali::Window result; - - { - try { - result = Dali::DevelWindow::Get(*(Dali::Actor*)jarg1); - } CALL_CATCH_EXCEPTION(0); - } - jresult = new Dali::Window((const Dali::Window &)result); - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_EventSignal(void * jarg1) { - void * jresult ; - Dali::Window *arg1 = (Dali::Window *) 0 ; - Dali::DevelWindow::TransitionEffectEventSignalType *result = 0 ; - - arg1 = (Dali::Window *)jarg1; - { - try { - result = (Dali::DevelWindow::TransitionEffectEventSignalType *) &(Dali::DevelWindow::TransitionEffectEventSignal(*arg1)); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Window_Transition_Effect_Event_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)jarg1; - { - try { - result = Dali_Signal_Window_Transition_Effect_Event_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *) 0 ; - void (*arg2)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) = (void (*)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)jarg1; - arg2 = (void (*)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType))jarg2; - { - try { - //DALI_LOG_ERROR("CSharp_Dali_Window_Transition_Effect_Event_Signal_Connect(arg1=0x%x, arg2=0x%x) \n", arg1, arg2); - Dali_Signal_Window_Transition_Effect_Event_Signal_Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *) 0 ; - void (*arg2)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) = (void (*)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)jarg1; - arg2 = (void (*)(Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType))jarg2; - { - try { - Dali_Signal_Window_Transition_Effect_Event_Signal_Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_Emit(void * jarg1, void * jarg2, int jarg3, int jarg4) { - Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *) 0 ; - Dali::Window arg2 ; - Dali::Window *argp2 ; - - arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)jarg1; - argp2 = (Dali::Window *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - arg2 = *argp2; - { - try { - Dali_Signal_Window_Transition_Effect_Event_Signal_Emit(arg1,arg2, (Dali::WindowEffectState)jarg3, (Dali::WindowEffectType)jarg4); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_new() { - void * jresult ; - Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)new Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Transition_Effect_Event_Signal_delete(void * jarg1) { - Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Window, Dali::WindowEffectState, Dali::WindowEffectType) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -//////////////////////////////////////////////////////////////////// -/// Auxiliary Message event - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Auxiliary_Message_Signal(void * jarg1) { - void * jresult ; - Dali::Window *window = (Dali::Window *) 0 ; - Dali::DevelWindow::AuxiliaryMessageSignalType *result = 0 ; - - window = (Dali::Window *)jarg1; - { - try { - result = (Dali::DevelWindow::AuxiliaryMessageSignalType *) &(Dali::DevelWindow::AuxiliaryMessageSignal(*window)); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_Auxiliary_Message_Signal_Empty(void * jarg1) { - bool result; - Dali::DevelWindow::AuxiliaryMessageSignalType* arg1 = (Dali::DevelWindow::AuxiliaryMessageSignalType*) jarg1; - - if (arg1 == nullptr) { - DALI_LOG_ERROR("[ERR] arg1 == nullptr"); - return false; - } - - { - try { - result = arg1->Empty(); - } - CALL_CATCH_EXCEPTION(false); - } - return result; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Window_Auxiliary_Message_Signal_GetConnectionCount(void * jarg1) { - unsigned int result; - Dali::DevelWindow::AuxiliaryMessageSignalType* arg1 = (Dali::DevelWindow::AuxiliaryMessageSignalType *) jarg1; - - if (arg1 == nullptr) { - DALI_LOG_ERROR("[ERR] arg1 == nullptr"); - return 0; - } - - { - try { - result = arg1->GetConnectionCount(); - } - CALL_CATCH_EXCEPTION(0); - } - return result; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Auxiliary_Message_Signal_Connect(void * jarg1, void * jarg2) { - Dali::DevelWindow::AuxiliaryMessageSignalType* arg1 = (Dali::DevelWindow::AuxiliaryMessageSignalType *)jarg1; - void (*arg2)(const std::string&, const std::string&, const Dali::Property::Array&) = ( void (*)(const std::string&, const std::string&, const Dali::Property::Array&) )jarg2; - - if (arg1 == nullptr) { - DALI_LOG_ERROR("[ERR] arg1 == nullptr"); - return ; - } - - { - try { - arg1->Connect(arg2); - } - CALL_CATCH_EXCEPTION(); - } - return ; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Auxiliary_Message_Signal_Disconnect(void * jarg1, void * jarg2) { - Dali::DevelWindow::AuxiliaryMessageSignalType* arg1 = (Dali::DevelWindow::AuxiliaryMessageSignalType *)jarg1; - void (*arg2)(const std::string&, const std::string&, const Dali::Property::Array&) = ( void (*)(const std::string&, const std::string&, const Dali::Property::Array&) )jarg2; - - if (arg1 == nullptr) { - DALI_LOG_ERROR("[ERR] arg1 == nullptr"); - return; - } - - { - try { - arg1->Disconnect(arg2); - } - CALL_CATCH_EXCEPTION(); - } - return; -} - -///////////////// -// Keyboard Repeat Settings Changed -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_ChangedSignal(void * jarg1) { - void * jresult ; - Dali::Window *arg1 = (Dali::Window *) 0 ; - Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *result = 0 ; - - arg1 = (Dali::Window *)jarg1; - { - try { - result = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *) &(Dali::DevelWindow::KeyboardRepeatSettingsChangedSignal(*arg1)); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_Empty(void * jarg1) { - unsigned int jresult ; - Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType*)jarg1; - if (arg1 == nullptr) { - DALI_LOG_ERROR("[ERR] arg1 == nullptr"); - return false; - } - - bool result; - { - try { - result = (bool)((Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType const *)arg1)->Empty(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *)jarg1; - if (arg1 == nullptr) { - DALI_LOG_ERROR("[ERR] arg1 == nullptr"); - return false; - } - - std::size_t result; - { - try { - result = ((Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType const *)arg1)->GetConnectionCount(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_Connect(void * jarg1, void * jarg2) { - Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *)jarg1; - void (*arg2)() = (void (*)())jarg2; - - if (arg1 == nullptr) { - DALI_LOG_ERROR("[ERR] arg1 == nullptr"); - return; - } - - { - try { - (arg1)->Connect(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_Disconnect(void * jarg1, void * jarg2) { - Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *)jarg1; - void (*arg2)() = (void (*)())jarg2; - - if (arg1 == nullptr) { - DALI_LOG_ERROR("[ERR] arg1 == nullptr"); - return; - } - - { - try { - (arg1)->Disconnect(arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_Emit(void * jarg1) { - Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *)jarg1; - - if (arg1 == nullptr) { - DALI_LOG_ERROR("[ERR] arg1 == nullptr"); - return; - } - - { - try { - (arg1)->Emit(); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_new() { - void * jresult ; - Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *result = 0; - - { - try { - result = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *)new Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Keyboard_Repeat_Settings_Changed_Signal_delete(void * jarg1) { - Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType*) 0; - - arg1 = (Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal(void* jarg1) { - Dali::Window* arg1 = (Dali::Window*) jarg1; - Dali::DevelWindow::VisibilityChangedSignalType* result = 0; - - { - try { - result = (Dali::DevelWindow::VisibilityChangedSignalType*) &( Dali::DevelWindow::VisibilityChangedSignal(*arg1) ); - } - CALL_CATCH_EXCEPTION(0); - } - return (void*)result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_Empty(void* jarg1) { - bool result; - Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType*) jarg1; - - if (arg1 == nullptr) { - DALI_LOG_ERROR("[ERR] arg1 == nullptr"); - return false; - } - - { - try { - result = arg1->Empty(); - } - CALL_CATCH_EXCEPTION(false); - } - return result; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_GetConnectionCount(void* jarg1) { - unsigned int result; - Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType *) jarg1; - - if (arg1 == nullptr) { - DALI_LOG_ERROR("[ERR] arg1 == nullptr"); - return 0; - } - - { - try { - result = arg1->GetConnectionCount(); - } - CALL_CATCH_EXCEPTION(0); - } - return result; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_Connect(void* jarg1, void* jarg2) { - Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType *)jarg1; - void (*arg2)(Dali::Window, bool) = ( void (*)(Dali::Window, bool) )jarg2; - - if (arg1 == nullptr) { - DALI_LOG_ERROR("[ERR] arg1 == nullptr"); - return ; - } - - { - try { - arg1->Connect(arg2); - } - CALL_CATCH_EXCEPTION(); - } - return ; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_Disconnect(void* jarg1, void* jarg2) { - Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType*)jarg1; - void (*arg2)(Dali::Window, bool) = (void (*)(Dali::Window, bool))jarg2; - - if (arg1 == nullptr) { - DALI_LOG_ERROR("[ERR] arg1 == nullptr"); - return; - } - - { - try { - arg1->Disconnect(arg2); - } - CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_Emit(void* jarg1, void* jarg2, bool jarg3) { - Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType*)jarg1; - Dali::Window* arg2 = (Dali::Window*)jarg2; - bool arg3 = jarg3; - - if (arg1 == nullptr || arg2 == nullptr) { - DALI_LOG_ERROR("[ERR] arg1 == nullptr or arg2 == nullptr"); - return; - } - - { - try { - arg1->Emit(*arg2, arg3); - } - CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Visibility_Changed_Signal_delete(void* jarg1) { - Dali::DevelWindow::VisibilityChangedSignalType* arg1 = (Dali::DevelWindow::VisibilityChangedSignalType*)jarg1; - - { - try { - delete arg1; - } - CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT int32_t SWIGSTDCALL CSharp_Dali_Window_GetNativeId( void* jarg1 ) -{ - Dali::Window* window = (Dali::Window*)jarg1; - int32_t ret = -1; - if( !window ) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ret; - } - - { - try { - ret = Dali::DevelWindow::GetNativeId( *window ); - } - CALL_CATCH_EXCEPTION(ret); - } - return ret; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddFrameRenderedCallback( void* nuiWindow, void* nuiCallback, int nuiFrameId ) -{ - Dali::Window* window = (Dali::Window*)nuiWindow; - void (*callback)(int32_t) = (void (*)(int32_t))nuiCallback; - - if( !window || !callback ) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null", 0); - return; - } - - try - { - Dali::DevelWindow::AddFrameRenderedCallback( *window, std::unique_ptr< Dali::CallbackBase >( Dali::MakeCallback( callback ) ), nuiFrameId ); - } - CALL_CATCH_EXCEPTION(); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddFramePresentedCallback( void* nuiWindow, void* nuiCallback, int nuiFrameId ) -{ - Dali::Window* window = (Dali::Window*)nuiWindow; - void (*callback)(int32_t) = (void (*)(int32_t))nuiCallback; - - if( !window || !callback ) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null", 0); - return; - } - - try - { - Dali::DevelWindow::AddFramePresentedCallback( *window, std::unique_ptr< Dali::CallbackBase >( Dali::MakeCallback( callback ) ), nuiFrameId ); - } - CALL_CATCH_EXCEPTION(); -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPositionSizeWithOrientation(void* jarg1, void* jarg2, int jarg3) -{ - Dali::Window* window = (Dali::Window*)jarg1; - if (!window) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - - Dali::Rect* positionSize = (Dali::Rect*)jarg2; - if (!positionSize) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0); - return ; - } - - Dali::WindowOrientation orientation = (Dali::WindowOrientation)jarg3; - { - try { - Dali::DevelWindow::SetPositionSizeWithOrientation(*window, *positionSize, orientation); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RequestMoveToServer(void* jarg1) -{ - Dali::Window* window = (Dali::Window*)jarg1; - if (!window) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - - { - try { - Dali::DevelWindow::RequestMoveToServer(*window); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RequestResizeToServer(void* jarg1, int jarg2) -{ - Dali::Window* window = (Dali::Window*)jarg1; - if (!window) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - - Dali::WindowResizeDirection direction = (Dali::WindowResizeDirection)jarg2; - - { - try { - Dali::DevelWindow::RequestResizeToServer(*window, direction); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_EnableFloatingMode(void* jarg1, bool jarg2) -{ - Dali::Window* window = (Dali::Window*)jarg1; - if (!window) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return; - } - - bool enable = jarg2; - { - try { - Dali::DevelWindow::EnableFloatingMode(*window, enable); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_IsFloatingModeEnabled(void* winHandle) -{ - Dali::Window* window = (Dali::Window*)winHandle; - bool result = false; - if (!window) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return false; - } - - { - try { - result = Dali::DevelWindow::IsFloatingModeEnabled(*window); - } CALL_CATCH_EXCEPTION(0); - } - return result; - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_IncludeInputRegion(void* winHandle, void* region) -{ - Dali::Window* window = (Dali::Window*)winHandle; - Dali::Rect *addedRegion = (Dali::Rect *)region; - if (!window) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return; - } - { - try { - Dali::DevelWindow::IncludeInputRegion(*window, *addedRegion); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ExcludeInputRegion(void* winHandle, void* region) -{ - Dali::Window* window = (Dali::Window*)winHandle; - Dali::Rect *subtractedRegion = (Dali::Rect *)region; - if (!window) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return; - } - { - try { - Dali::DevelWindow::ExcludeInputRegion(*window, *subtractedRegion); - } CALL_CATCH_EXCEPTION(); - } - -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_KeepRendering(void* winHandle, float durationSeconds) -{ - Dali::Window* window = static_cast(winHandle); - if(!window) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return; - } - { - try - { - window->KeepRendering(durationSeconds); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPartialUpdateEnabled(void* winHandle, bool enabled) -{ - Dali::Window* window = static_cast(winHandle); - if(!window) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return; - } - { - try - { - window->SetPartialUpdateEnabled(enabled); - } - CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_IsPartialUpdateEnabled(void* winHandle) -{ - Dali::Window* window = static_cast(winHandle); - bool enabled = false; - if(!window) - { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return false; - } - { - try - { - enabled = window->IsPartialUpdateEnabled(); - } - CALL_CATCH_EXCEPTION(false); - } - return enabled; -} - -SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal(void* winHandle) { - Dali::Window* window = (Dali::Window*) winHandle; - Dali::DevelWindow::AccessibilityHighlightSignalType* result = 0; - - { - try { - result = (Dali::DevelWindow::AccessibilityHighlightSignalType*) &( Dali::DevelWindow::AccessibilityHighlightSignal(*window) ); - } - CALL_CATCH_EXCEPTION(0); - } - return (void*)result; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_Empty(void* accessibilityHighlightSignalTypeHandle) { - bool result; - Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType*) accessibilityHighlightSignalTypeHandle; - - if (accessibilityHighlightSignalType == nullptr) { - DALI_LOG_ERROR("[ERR] accessibilityHighlightSignalType == nullptr"); - return false; - } - - { - try { - result = accessibilityHighlightSignalType->Empty(); - } - CALL_CATCH_EXCEPTION(false); - } - return result; -} - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_GetConnectionCount(void* accessibilityHighlightSignalTypeHandle) { - unsigned int result; - Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType *) accessibilityHighlightSignalTypeHandle; - - if (accessibilityHighlightSignalType == nullptr) { - DALI_LOG_ERROR("[ERR] accessibilityHighlightSignalType == nullptr"); - return 0; - } - - { - try { - result = accessibilityHighlightSignalType->GetConnectionCount(); - } - CALL_CATCH_EXCEPTION(0); - } - return result; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_Connect(void* accessibilityHighlightSignalTypeHandle, void* winHandle) { - Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType *)accessibilityHighlightSignalTypeHandle; - void (*window)(Dali::Window, bool) = ( void (*)(Dali::Window, bool) )winHandle; - - if (accessibilityHighlightSignalType == nullptr) { - DALI_LOG_ERROR("[ERR] accessibilityHighlightSignalType == nullptr"); - return ; - } - - { - try { - accessibilityHighlightSignalType->Connect(window); - } - CALL_CATCH_EXCEPTION(); - } - return ; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_Disconnect(void* accessibilityHighlightSignalTypeHandle, void* winHandle) { - Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType*)accessibilityHighlightSignalTypeHandle; - void (*window)(Dali::Window, bool) = (void (*)(Dali::Window, bool))winHandle; - - if (accessibilityHighlightSignalType == nullptr) { - DALI_LOG_ERROR("[ERR] accessibilityHighlightSignalType == nullptr"); - return; - } - - { - try { - accessibilityHighlightSignalType->Disconnect(window); - } - CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Accessibility_Highlight_Signal_delete(void* accessibilityHighlightSignalTypeHandle) { - Dali::DevelWindow::AccessibilityHighlightSignalType* accessibilityHighlightSignalType = (Dali::DevelWindow::AccessibilityHighlightSignalType*)accessibilityHighlightSignalTypeHandle; - - { - try { - delete accessibilityHighlightSignalType; - } - CALL_CATCH_EXCEPTION(); - } - return; -} - -SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Window_IsWindowRotating(void* winHandle) -{ - Dali::Window* window = (Dali::Window*)winHandle; - bool result = false; - if (!window) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return result; - } - { - try { - result = Dali::DevelWindow::IsWindowRotating(*window); - } CALL_CATCH_EXCEPTION(false); - } - - return result; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetLastKeyEvent(void* winHandle) -{ - Dali::Window* window = (Dali::Window*)winHandle; - void * jresult; - Dali::KeyEvent *result = 0; - if (!window) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - { - try { - result = (Dali::KeyEvent *)&Dali::DevelWindow::GetLastKeyEvent(*window); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetLastTouchEvent(void* winHandle) -{ - Dali::Window* window = (Dali::Window*)winHandle; - void * jresult; - Dali::TouchEvent *result = 0; - if (!window) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - { - try { - result = (Dali::TouchEvent *)&Dali::DevelWindow::GetLastTouchEvent(*window); - } CALL_CATCH_EXCEPTION(0); - } - jresult = (void *)result; - return jresult; -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_InternalRetrievingLastKeyEvent(void* winHandle, void* keyHandle) -{ - Dali::Window* window = (Dali::Window*)winHandle; - Dali::KeyEvent* keyEvent = (Dali::KeyEvent*)keyHandle; - - if (!window) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return; - } - if (!keyEvent) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::KeyEvent", 0); - return; - } - { - try { - (*keyEvent) = *((Dali::KeyEvent *)&Dali::DevelWindow::GetLastKeyEvent(*window)); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_InternalRetrievingLastTouchEvent(void* winHandle, void* touchHandle) -{ - Dali::Window* window = (Dali::Window*)winHandle; - Dali::TouchEvent* touchEvent = (Dali::TouchEvent*)touchHandle; - - if (!window) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return; - } - if (!touchEvent) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TouchEvent", 0); - return; - } - { - try { - (*touchEvent) = *((Dali::TouchEvent *)&Dali::DevelWindow::GetLastTouchEvent(*window)); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetNeedsRotationCompletedAcknowledgement(void* winHandle, bool needAcknowledgement) -{ - Dali::Window* window = (Dali::Window*)winHandle; - if (!window) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return; - } - { - try { - Dali::DevelWindow::SetNeedsRotationCompletedAcknowledgement(*window, needAcknowledgement); - } CALL_CATCH_EXCEPTION(); - } -} - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SendRotationCompletedAcknowledgement(void* winHandle) -{ - Dali::Window* window = (Dali::Window*)winHandle; - if (!window) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return; - } - { - try { - Dali::DevelWindow::SendRotationCompletedAcknowledgement(*window); - } CALL_CATCH_EXCEPTION(); - } -} - -/* Moved signal binding */ -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Moved_Signal(void* winHandle) -{ - void *result; - Dali::Window window; - Dali::Window *win; - Dali::DevelWindow::MovedSignalType* movedSignal; - - win = (Dali::Window *)winHandle; - if (!win) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - window = *win; - { - try { - movedSignal = (Dali::DevelWindow::MovedSignalType *) &Dali::DevelWindow::MovedSignal(window); - } CALL_CATCH_EXCEPTION(0); - } - - result = (void *)movedSignal; - return result; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Moved_Signal_Empty(void * signal) -{ - unsigned int result; - Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; - bool flag; - - movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; - { - try { - flag = (bool)Dali_Signal_Window_Moved_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *)movedSignal); - } CALL_CATCH_EXCEPTION(0); - } - - result = (unsigned int)flag; - return result; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Moved_Signal_GetConnectionCount(void * signal) { - unsigned long result; - Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; - std::size_t count; - - movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; - { - try { - count = Dali_Signal_Window_Moved_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *)movedSignal); - } CALL_CATCH_EXCEPTION(0); - } - - result = (unsigned long)count; - return result; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Moved_Signal_Connect(void * signal, void * func) { - Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; - void (*functionPtr)(Dali::Window, Dali::Window::WindowPosition) = (void (*)(Dali::Window, Dali::Window::WindowPosition)) 0 ; - - movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; - functionPtr = (void (*)(Dali::Window, Dali::Window::WindowPosition))func; - { - try { - Dali_Signal_Window_Moved_Signal_Connect(movedSignal, functionPtr); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Moved_Signal_Disconnect(void * signal, void * func) { - Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; - void (*functionPtr)(Dali::Window, Dali::Window::WindowPosition) = (void (*)(Dali::Window, Dali::Window::WindowPosition)) 0 ; - - movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; - functionPtr = (void (*)(Dali::Window, Dali::Window::WindowPosition))func; - { - try { - Dali_Signal_Window_Moved_Signal_Disconnect(movedSignal, functionPtr); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Moved_Signal_Emit(void * signal, void* winHandle, void * position) { - Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; - Dali::Window* win = (Dali::Window*)winHandle; - Dali::Window window; - Dali::Window::WindowPosition windowPosition; - Dali::Window::WindowPosition *pPosition; - - movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; - if (movedSignal == nullptr || window == nullptr) { - DALI_LOG_ERROR("[ERR] movedSignal == nullptr or window == nullptr"); - return; - } - - pPosition = (Dali::Window::WindowPosition *)position; - if (!pPosition) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); - return ; - } - window = *win; - windowPosition = *pPosition; - { - try { - Dali_Signal_Window_Moved_Signal_Emit(movedSignal, window, windowPosition); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Moved_Signal() { - void * result ; - Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = 0 ; - - { - try { - movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)new Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) >(); - } CALL_CATCH_EXCEPTION(0); - } - - result = (void *)movedSignal; - return result; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Moved_Signal(void * signal) { - Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; - - movedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; - { - try { - delete movedSignal; - } CALL_CATCH_EXCEPTION(); - } - -} - -/* Orientation Changed signal binding */ -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Orientation_Changed_Signal(void* winHandle) -{ - void *result; - Dali::Window window; - Dali::Window *win; - Dali::DevelWindow::OrientationChangedSignalType* orientationChangedSignal; - - win = (Dali::Window *)winHandle; - if (!win) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - window = *win; - { - try { - orientationChangedSignal = (Dali::DevelWindow::OrientationChangedSignalType *) &Dali::DevelWindow::OrientationChangedSignal(window); - } CALL_CATCH_EXCEPTION(0); - } - - result = (void *)orientationChangedSignal; - return result; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Orientation_Changed_Signal_Empty(void * signal) -{ - unsigned int result; - Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ; - bool flag; - - orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal; - { - try { - flag = (bool)Dali_Signal_Window_Orientation_Changed_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > const *)orientationChangedSignal); - } CALL_CATCH_EXCEPTION(0); - } - - result = (unsigned int)flag; - return result; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Orientation_Changed_Signal_GetConnectionCount(void * signal) { - unsigned long result; - Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ; - std::size_t count; - - orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal; - { - try { - count = Dali_Signal_Window_Orientation_Changed_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > const *)orientationChangedSignal); - } CALL_CATCH_EXCEPTION(0); - } - - result = (unsigned long)count; - return result; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Orientation_Changed_Signal_Connect(void * signal, void * func) { - Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ; - void (*functionPtr)(Dali::Window, Dali::WindowOrientation) = (void (*)(Dali::Window, Dali::WindowOrientation)) 0 ; - - orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal; - functionPtr = (void (*)(Dali::Window, Dali::WindowOrientation))func; - { - try { - Dali_Signal_Window_Orientation_Changed_Signal_Connect(orientationChangedSignal, functionPtr); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Orientation_Changed_Signal_Disconnect(void * signal, void * func) { - Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ; - void (*functionPtr)(Dali::Window, Dali::WindowOrientation) = (void (*)(Dali::Window, Dali::WindowOrientation)) 0 ; - - orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal; - functionPtr = (void (*)(Dali::Window, Dali::WindowOrientation))func; - { - try { - Dali_Signal_Window_Orientation_Changed_Signal_Disconnect(orientationChangedSignal, functionPtr); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Orientation_Changed_Signal_Emit(void * signal, void* winHandle, int orientation) { - Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ; - Dali::Window* win = (Dali::Window*)winHandle; - Dali::Window window; - Dali::WindowOrientation windowOrientation; - - orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal; - if (orientationChangedSignal == nullptr || window == nullptr) { - DALI_LOG_ERROR("[ERR] orientationChangedSignal == nullptr or window == nullptr"); - return; - } - - window = *win; - windowOrientation = static_cast(orientation); - { - try { - Dali_Signal_Window_Orientation_Changed_Signal_Emit(orientationChangedSignal, window, windowOrientation); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Orientation_Changed_Signal() { - void * result ; - Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = 0 ; - - { - try { - orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)new Dali::Signal< void (Dali::Window, Dali::WindowOrientation) >(); - } CALL_CATCH_EXCEPTION(0); - } - - result = (void *)orientationChangedSignal; - return result; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Orientation_Changed_Signal(void * signal) { - Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *) 0 ; - - orientationChangedSignal = (Dali::Signal< void (Dali::Window, Dali::WindowOrientation) > *)signal; - { - try { - delete orientationChangedSignal; - } CALL_CATCH_EXCEPTION(); - } - -} - -// -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal(void* winHandle) -{ - void *result; - Dali::Window window; - Dali::Window *win; - Dali::DevelWindow::MouseInOutEventSignalType* mouseInOutSignal; - - win = (Dali::Window *)winHandle; - if (!win) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - window = *win; - { - try { - mouseInOutSignal = (Dali::DevelWindow::MouseInOutEventSignalType *) &Dali::DevelWindow::MouseInOutEventSignal(window); - } CALL_CATCH_EXCEPTION(0); - } - - result = (void *)mouseInOutSignal; - return result; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_Empty(void * jarg1) { - unsigned int jresult ; - Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ; - bool result; - - arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1; - { - try { - result = (bool)Dali_Signal_Window_MouseInOutEvent_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_GetConnectionCount(void * jarg1) { - unsigned long jresult ; - Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ; - std::size_t result; - - arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1; - { - try { - result = Dali_Signal_Window_MouseInOutEvent_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > const *)arg1); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (unsigned long)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_Connect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ; - void (*arg2)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) = (void (*)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1; - arg2 = (void (*)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &))jarg2; - { - try { - Dali_Signal_Window_MouseInOutEvent_Signal_Connect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_Disconnect(void * jarg1, void * jarg2) { - Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ; - void (*arg2)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) = (void (*)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &)) 0 ; - - arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1; - arg2 = (void (*)(Dali::Window, Dali::DevelWindow::MouseInOutEvent const &))jarg2; - { - try { - Dali_Signal_Window_MouseInOutEvent_Signal_Disconnect(arg1,arg2); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowMouseInOutEventSignal_Emit(void * jarg1, void* jarg2, void* jarg3) { - Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1; - Dali::Window* arg2 = (Dali::Window*)jarg2; - Dali::DevelWindow::MouseInOutEvent* arg3 = (Dali::DevelWindow::MouseInOutEvent*)jarg3; - - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Signal", 0); - return ; - } - - if (!arg2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return ; - } - - if (!arg3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::DevelWindow::MouseInOutEvent", 0); - return ; - } - - { - try { - Dali_Signal_Window_MouseInOutEvent_Signal_Emit(arg1,*arg2,*arg3); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowMouseInOutEventSignal() { - void * jresult ; - Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *result = 0 ; - - { - try { - result = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)new Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) >(); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowMouseInOutEventSignal(void * jarg1) { - Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *) 0 ; - - arg1 = (Dali::Signal< void (Dali::Window, Dali::DevelWindow::MouseInOutEvent const &) > *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_MouseInOutEvent__SWIG_0(int jarg1, unsigned int jarg2, void * jarg3, unsigned int jarg4) { - void * jresult ; - Dali::DevelWindow::MouseInOutEvent::Type arg1 ; - unsigned int arg2 ; - Dali::Vector2 arg3 ; - unsigned int arg4 ; - - Dali::Vector2 *argp3 ; - - Dali::DevelWindow::MouseInOutEvent *result = 0; - - arg1 = static_cast(jarg1); - arg2 = (unsigned int)jarg2; - argp3 = (Dali::Vector2 *)jarg3; - if (!argp3) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); - return 0; - } - arg3 = *argp3; - arg4 = (unsigned int)jarg4; - { - try { - result = (Dali::DevelWindow::MouseInOutEvent *)new Dali::DevelWindow::MouseInOutEvent(arg1, arg2, arg3, arg4, Dali::Device::Class::NONE, Dali::Device::Subclass::NONE); - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_MouseInOutEvent(void * jarg1) { - Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ; - - arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1; - { - try { - delete arg1; - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_type_get(void * jarg1) { - int jresult ; - Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ; - Dali::DevelWindow::MouseInOutEvent::Type result; - - arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1; - { - try { - result = ((Dali::DevelWindow::MouseInOutEvent const *)arg1)->type; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_modifiers_get(void * jarg1) { - unsigned int jresult ; - Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ; - unsigned int result; - - arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1; - { - try { - result = ((Dali::DevelWindow::MouseInOutEvent const *)arg1)->modifiers; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MouseInOutEvent_point_get(void * jarg1) { - void * jresult ; - Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ; - Dali::Vector2 *result = 0 ; - - arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1; - { - try { - result = (Dali::Vector2 *) &((Dali::DevelWindow::MouseInOutEvent const *)arg1)->point; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (void *)result; - return jresult; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_timeStamp_get(void * jarg1) { - unsigned int jresult ; - Dali::DevelWindow::MouseInOutEvent *arg1 = (Dali::DevelWindow::MouseInOutEvent *) 0 ; - unsigned int result; - - arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1; - { - try { - result = ((Dali::DevelWindow::MouseInOutEvent const *)arg1)->timeStamp; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = result; - return jresult; -} - - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_GetDeviceClass(void * jarg1) { - int jresult ; - Dali::DevelWindow::MouseInOutEvent *arg1 = 0 ; - Dali::Device::Class::Type result; - - arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelWindow::MouseInOutEvent const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Device::Class::Type)arg1->deviceClass; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MouseInOutEvent_GetDeviceSubClass(void * jarg1) { - int jresult ; - Dali::DevelWindow::MouseInOutEvent *arg1 = 0 ; - Dali::Device::Subclass::Type result; - - arg1 = (Dali::DevelWindow::MouseInOutEvent *)jarg1; - if (!arg1) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelWindow::MouseInOutEvent const & type is null", 0); - return 0; - } - { - try { - result = (Dali::Device::Subclass::Type)arg1->deviceSubclass; - } CALL_CATCH_EXCEPTION(0); - } - - jresult = (int)result; - return jresult; -} - -/* Move Completed signal binding */ -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Move_Completed_Signal(void* winHandle) -{ - void *result; - Dali::Window window; - Dali::Window *win; - Dali::DevelWindow::MoveCompletedSignalType* moveCompletedSignal; - - win = (Dali::Window *)winHandle; - if (!win) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - window = *win; - { - try { - moveCompletedSignal = (Dali::DevelWindow::MoveCompletedSignalType *) &Dali::DevelWindow::MoveCompletedSignal(window); - } CALL_CATCH_EXCEPTION(0); - } - - result = (void *)moveCompletedSignal; - return result; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Move_Completed_Signal_Empty(void * signal) -{ - unsigned int result; - Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; - bool flag; - - moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; - { - try { - flag = (bool)Dali_Signal_Window_Move_Completed_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *)moveCompletedSignal); - } CALL_CATCH_EXCEPTION(0); - } - - result = (unsigned int)flag; - return result; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Move_Completed_Signal_GetConnectionCount(void * signal) { - unsigned long result; - Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; - std::size_t count; - - moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; - { - try { - count = Dali_Signal_Window_Move_Completed_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > const *)moveCompletedSignal); - } CALL_CATCH_EXCEPTION(0); - } - - result = (unsigned long)count; - return result; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Move_Completed_Signal_Connect(void * signal, void * func) { - Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; - void (*functionPtr)(Dali::Window, Dali::Window::WindowPosition) = (void (*)(Dali::Window, Dali::Window::WindowPosition)) 0 ; - - moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; - functionPtr = (void (*)(Dali::Window, Dali::Window::WindowPosition))func; - { - try { - Dali_Signal_Window_Move_Completed_Signal_Connect(moveCompletedSignal, functionPtr); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Move_Completed_Signal_Disconnect(void * signal, void * func) { - Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; - void (*functionPtr)(Dali::Window, Dali::Window::WindowPosition) = (void (*)(Dali::Window, Dali::Window::WindowPosition)) 0 ; - - moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; - functionPtr = (void (*)(Dali::Window, Dali::Window::WindowPosition))func; - { - try { - Dali_Signal_Window_Move_Completed_Signal_Disconnect(moveCompletedSignal, functionPtr); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Move_Completed_Signal_Emit(void * signal, void* winHandle, void * position) { - Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; - Dali::Window* win = (Dali::Window*)winHandle; - Dali::Window window; - Dali::Window::WindowPosition windowPosition; - Dali::Window::WindowPosition *pPosition; - - moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; - if (moveCompletedSignal == nullptr || window == nullptr) { - DALI_LOG_ERROR("[ERR] moveCompletedSignal == nullptr or window == nullptr"); - return; - } - - pPosition = (Dali::Window::WindowPosition *)position; - if (!pPosition) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); - return ; - } - window = *win; - windowPosition = *pPosition; - { - try { - Dali_Signal_Window_Move_Completed_Signal_Emit(moveCompletedSignal, window, windowPosition); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Move_Completed_Signal() { - void * result ; - Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = 0 ; - - { - try { - moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)new Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) >(); - } CALL_CATCH_EXCEPTION(0); - } - - result = (void *)moveCompletedSignal; - return result; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Move_Completed_Signal(void * signal) { - Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *) 0 ; - - moveCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowPosition) > *)signal; - { - try { - delete moveCompletedSignal; - } CALL_CATCH_EXCEPTION(); - } - -} - -/* Resized Completed signal binding */ -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Resize_Completed_Signal(void* winHandle) -{ - void *result; - Dali::Window window; - Dali::Window *win; - Dali::DevelWindow::ResizeCompletedSignalType* resizeCompletedSignal; - - win = (Dali::Window *)winHandle; - if (!win) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0); - return 0; - } - window = *win; - { - try { - resizeCompletedSignal = (Dali::DevelWindow::ResizeCompletedSignalType *) &Dali::DevelWindow::ResizeCompletedSignal(window); - } CALL_CATCH_EXCEPTION(0); - } - - result = (void *)resizeCompletedSignal; - return result; -} - - -SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Resize_Completed_Signal_Empty(void * signal) -{ - unsigned int result; - Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; - bool flag; - - resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal; - { - try { - flag = (bool)Dali_Signal_Window_Resize_Completed_Signal_Empty((Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *)resizeCompletedSignal); - } CALL_CATCH_EXCEPTION(0); - } - - result = (unsigned int)flag; - return result; -} - - -SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Resize_Completed_Signal_GetConnectionCount(void * signal) { - unsigned long result; - Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; - std::size_t count; - - resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal; - { - try { - count = Dali_Signal_Window_Resize_Completed_Signal_GetConnectionCount((Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > const *)resizeCompletedSignal); - } CALL_CATCH_EXCEPTION(0); - } - - result = (unsigned long)count; - return result; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Resize_Completed_Signal_Connect(void * signal, void * func) { - Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; - void (*functionPtr)(Dali::Window, Dali::Window::WindowSize) = (void (*)(Dali::Window, Dali::Window::WindowSize)) 0 ; - - resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal; - functionPtr = (void (*)(Dali::Window, Dali::Window::WindowSize))func; - { - try { - Dali_Signal_Window_Resize_Completed_Signal_Connect(resizeCompletedSignal, functionPtr); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Resize_Completed_Signal_Disconnect(void * signal, void * func) { - Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; - void (*functionPtr)(Dali::Window, Dali::Window::WindowSize) = (void (*)(Dali::Window, Dali::Window::WindowSize)) 0 ; - - resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal; - functionPtr = (void (*)(Dali::Window, Dali::Window::WindowSize))func; - { - try { - Dali_Signal_Window_Resize_Completed_Signal_Disconnect(resizeCompletedSignal, functionPtr); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Resize_Completed_Signal_Emit(void * signal, void* winHandle, void * size) { - Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; - Dali::Window* win = (Dali::Window*)winHandle; - Dali::Window window; - Dali::Window::WindowSize windowSize; - Dali::Window::WindowSize *pSize; - - resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal; - if (resizeCompletedSignal == nullptr || window == nullptr) { - DALI_LOG_ERROR("[ERR] resizeCompletedSignal == nullptr or window == nullptr"); - return; - } - - pSize = (Dali::Window::WindowSize *)size; - if (!pSize) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0); - return ; - } - window = *win; - windowSize = *pSize; - { - try { - Dali_Signal_Window_Resize_Completed_Signal_Emit(resizeCompletedSignal, window, windowSize); - } CALL_CATCH_EXCEPTION(); - } - -} - - -SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Resize_Completed_Signal() { - void * result ; - Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = 0 ; - - { - try { - resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)new Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) >(); - } CALL_CATCH_EXCEPTION(0); - } - - result = (void *)resizeCompletedSignal; - return result; -} - - -SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Resize_Completed_Signal(void * signal) { - Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *) 0 ; - - resizeCompletedSignal = (Dali::Signal< void (Dali::Window, Dali::Window::WindowSize) > *)signal; - { - try { - delete resizeCompletedSignal; - } CALL_CATCH_EXCEPTION(); - } - -} - - -#ifdef __cplusplus -} -#endif diff --git a/dali-csharp-binder/widget-viewer-dali/watch-view-wrap.cpp b/dali-csharp-binder/widget-viewer-dali/watch-view-wrap.cpp new file mode 100755 index 00000000..31ba82c0 --- /dev/null +++ b/dali-csharp-binder/widget-viewer-dali/watch-view-wrap.cpp @@ -0,0 +1,206 @@ +/* + * Copyright (c) 2020 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. + * + */ + +// EXTERNAL INCLUDES +#include +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WatchView_SWIGUpcast(Dali::WatchView::WatchView *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchView_New(void * nuiWindow, char * nuiWatchId, char * nuiContentInfo, int nuiWidth, int nuiHeight) { + void * jresult ; + Dali::Window* window = (Dali::Window*)nuiWindow ; + std::string *watchId = 0 ; + std::string *contentInfo = 0 ; + int width ; + int height ; + Dali::WatchView::WatchView result; + + if (!nuiWatchId) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string watchid_str(nuiWatchId); + watchId = &watchid_str; + + if (!nuiContentInfo) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string contenInfo_str(nuiContentInfo); + contentInfo = &contenInfo_str; + width = (int)nuiWidth; + height = (int)nuiHeight; + + { + try { + result = Dali::WatchView::WatchView::New( *window,(std::string const &)*watchId,(std::string const &)*contentInfo,width,height); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::WatchView::WatchView((const Dali::WatchView::WatchView &)result); + + //argout typemap for const std::string& + + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchView_DownCast(void * nuiHandle) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::WatchView::WatchView result; + + argp1 = (Dali::BaseHandle *)nuiHandle; + if (!argp1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0); + return 0; + } + arg1 = *argp1; + { + try { + result = Dali::WatchView::WatchView::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::WatchView::WatchView((const Dali::WatchView::WatchView &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchView__SWIG_0() { + void * jresult ; + Dali::WatchView::WatchView *result = 0 ; + + { + try { + result = (Dali::WatchView::WatchView *)new Dali::WatchView::WatchView(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WatchView__SWIG_1(void * nuiHandle) { + void * jresult ; + Dali::WatchView::WatchView *handle = 0 ; + Dali::WatchView::WatchView *result = 0 ; + + handle = (Dali::WatchView::WatchView *)nuiHandle; + if (!handle) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WatchView::WatchView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::WatchView::WatchView *)new Dali::WatchView::WatchView((Dali::WatchView::WatchView const &)*handle); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WatchView_Assign(void * nuiWatchview1, void * nuiWatchview2) { + void * jresult ; + Dali::WatchView::WatchView *watchView1 = (Dali::WatchView::WatchView *) 0 ; + Dali::WatchView::WatchView *watchView2 = 0 ; + Dali::WatchView::WatchView *result = 0 ; + + watchView1 = (Dali::WatchView::WatchView *)nuiWatchview1; + watchView2 = (Dali::WatchView::WatchView *)nuiWatchview2; + if (!watchView2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetView::WidgetView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::WatchView::WatchView *) &(watchView1)->operator =((Dali::WatchView::WatchView const &)*watchView2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WatchView(void * nuiWatchview) { + Dali::WatchView::WatchView *watchView = (Dali::WatchView::WatchView *) 0 ; + + watchView = (Dali::WatchView::WatchView *)nuiWatchview; + { + try { + delete watchView; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WatchView_PauseWatch(void * nuiWatchview) { + unsigned int jresult ; + Dali::WatchView::WatchView *watchView = (Dali::WatchView::WatchView *) 0 ; + bool result; + + watchView = (Dali::WatchView::WatchView *)nuiWatchview; + { + try { + result = (bool)(watchView)->PauseWatch(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WatchView_ResumeWatch(void * nuiWatchview) { + unsigned int jresult ; + Dali::WatchView::WatchView *watchView = (Dali::WatchView::WatchView *) 0 ; + bool result; + + watchView = (Dali::WatchView::WatchView *)nuiWatchview; + { + try { + result = (bool)(watchView)->ResumeWatch(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + +#ifdef __cplusplus +} +#endif + diff --git a/dali-csharp-binder/widget-viewer-dali/widget-view-manager-wrap.cpp b/dali-csharp-binder/widget-viewer-dali/widget-view-manager-wrap.cpp new file mode 100755 index 00000000..647692cc --- /dev/null +++ b/dali-csharp-binder/widget-viewer-dali/widget-view-manager-wrap.cpp @@ -0,0 +1,242 @@ +/* + * Copyright (c) 2017 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// EXTERNAL INCLUDES +#include +#include + +// INTERNAL INCLUDES +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + SWIGEXPORT Dali::BaseHandle *SWIGSTDCALL CSharp_Dali_WidgetViewManager_SWIGUpcast(Dali::WidgetView::WidgetViewManager *jarg1) + { + return (Dali::BaseHandle *)jarg1; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WidgetViewManager_New(void *jarg1, char *jarg2) + { + void *jresult; + Dali::Application arg1; + std::string *arg2 = 0; + Dali::Application *argp1; + Dali::WidgetView::WidgetViewManager result; + + argp1 = (Dali::Application *)jarg1; + if (!argp1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Application", 0); + return 0; + } + arg1 = *argp1; + if (!jarg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + { + try + { + result = Dali::WidgetView::WidgetViewManager::New(arg1, (std::string const &)*arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::WidgetView::WidgetViewManager((const Dali::WidgetView::WidgetViewManager &)result); + + //argout typemap for const std::string& + + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WidgetViewManager_DownCast(void *jarg1) + { + void *jresult; + Dali::BaseHandle arg1; + Dali::BaseHandle *argp1; + Dali::WidgetView::WidgetViewManager 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::WidgetView::WidgetViewManager::DownCast(arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::WidgetView::WidgetViewManager((const Dali::WidgetView::WidgetViewManager &)result); + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_WidgetViewManager__SWIG_0() + { + void *jresult; + Dali::WidgetView::WidgetViewManager *result = 0; + + { + try + { + result = (Dali::WidgetView::WidgetViewManager *)new Dali::WidgetView::WidgetViewManager(); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_WidgetViewManager__SWIG_1(void *jarg1) + { + void *jresult; + Dali::WidgetView::WidgetViewManager *arg1 = 0; + Dali::WidgetView::WidgetViewManager *result = 0; + + arg1 = (Dali::WidgetView::WidgetViewManager *)jarg1; + if (!arg1) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetView::WidgetViewManager const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::WidgetView::WidgetViewManager *)new Dali::WidgetView::WidgetViewManager((Dali::WidgetView::WidgetViewManager const &)*arg1); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WidgetViewManager_Assign(void *jarg1, void *jarg2) + { + void *jresult; + Dali::WidgetView::WidgetViewManager *arg1 = (Dali::WidgetView::WidgetViewManager *)0; + Dali::WidgetView::WidgetViewManager *arg2 = 0; + Dali::WidgetView::WidgetViewManager *result = 0; + + arg1 = (Dali::WidgetView::WidgetViewManager *)jarg1; + arg2 = (Dali::WidgetView::WidgetViewManager *)jarg2; + if (!arg2) + { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetView::WidgetViewManager const & type is null", 0); + return 0; + } + { + try + { + result = (Dali::WidgetView::WidgetViewManager *)&(arg1)->operator=((Dali::WidgetView::WidgetViewManager const &)*arg2); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; + } + + SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetViewManager(void *jarg1) + { + Dali::WidgetView::WidgetViewManager *arg1 = (Dali::WidgetView::WidgetViewManager *)0; + + arg1 = (Dali::WidgetView::WidgetViewManager *)jarg1; + { + try + { + delete arg1; + } + CALL_CATCH_EXCEPTION(); + } + } + + SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_WidgetViewManager_AddWidget(void *jarg1, char *jarg2, char *jarg3, int jarg4, int jarg5, float jarg6) + { + void *jresult; + Dali::WidgetView::WidgetViewManager *arg1 = (Dali::WidgetView::WidgetViewManager *)0; + std::string *arg2 = 0; + std::string *arg3 = 0; + int arg4; + int arg5; + float arg6; + Dali::WidgetView::WidgetView result; + + arg1 = (Dali::WidgetView::WidgetViewManager *)jarg1; + 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 = (int)jarg4; + arg5 = (int)jarg5; + arg6 = (float)jarg6; + { + try + { + result = (arg1)->AddWidget((std::string const &)*arg2, (std::string const &)*arg3, arg4, arg5, arg6); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::WidgetView::WidgetView((const Dali::WidgetView::WidgetView &)result); + return jresult; + } + + SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WidgetViewManager_RemoveWidget(void *jarg1, void *jarg2) + { + bool jresult; + Dali::WidgetView::WidgetViewManager *widgetViewManager = (Dali::WidgetView::WidgetViewManager *)0; + Dali::WidgetView::WidgetView *widgetView = (Dali::WidgetView::WidgetView *)0; + bool result; + + widgetViewManager = (Dali::WidgetView::WidgetViewManager *)jarg1; + widgetView = (Dali::WidgetView::WidgetView *)jarg2; + { + try + { + result = (widgetViewManager)->RemoveWidget(*widgetView); + } + CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; + } +#ifdef __cplusplus +} +#endif diff --git a/dali-csharp-binder/widget-viewer-dali/widget-view-wrap.cpp b/dali-csharp-binder/widget-viewer-dali/widget-view-wrap.cpp new file mode 100755 index 00000000..7d46c820 --- /dev/null +++ b/dali-csharp-binder/widget-viewer-dali/widget-view-wrap.cpp @@ -0,0 +1,618 @@ +/* + * Copyright (c) 2017 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// EXTERNAL INCLUDES +#include + +// INTERNAL INCLUDES +#include + +SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__Empty(Dali::Signal< void (Dali::WidgetView::WidgetView) > const *self){ + return self->Empty(); +} +SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WidgetView::WidgetView) > const *self){ + return self->GetConnectionCount(); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__Connect(Dali::Signal< void (Dali::WidgetView::WidgetView) > *self,void (*func)(Dali::WidgetView::WidgetView)){ + self->Connect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__Disconnect(Dali::Signal< void (Dali::WidgetView::WidgetView) > *self,void (*func)(Dali::WidgetView::WidgetView)){ + self->Disconnect( func ); +} +SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__Emit(Dali::Signal< void (Dali::WidgetView::WidgetView) > *self,Dali::WidgetView::WidgetView arg){ + self->Emit( arg ); +} + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WidgetView_SWIGUpcast(Dali::WidgetView::WidgetView *jarg1) { + return (Dali::Toolkit::Control *)jarg1; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_WIDGET_ID_get() { + int jresult ; + int result; + + result = (int)Dali::WidgetView::WidgetView::Property::WIDGET_ID; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_INSTANCE_ID_get() { + int jresult ; + int result; + + result = (int)Dali::WidgetView::WidgetView::Property::INSTANCE_ID; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_CONTENT_INFO_get() { + int jresult ; + int result; + + result = (int)Dali::WidgetView::WidgetView::Property::CONTENT_INFO; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_TITLE_get() { + int jresult ; + int result; + + result = (int)Dali::WidgetView::WidgetView::Property::TITLE; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_UPDATE_PERIOD_get() { + int jresult ; + int result; + + result = (int)Dali::WidgetView::WidgetView::Property::UPDATE_PERIOD; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_PREVIEW_get() { + int jresult ; + int result; + + result = (int)Dali::WidgetView::WidgetView::Property::PREVIEW; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_LOADING_TEXT_get() { + int jresult ; + int result; + + result = (int)Dali::WidgetView::WidgetView::Property::LOADING_TEXT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_WIDGET_STATE_FAULTED_get() { + int jresult ; + int result; + + result = (int)Dali::WidgetView::WidgetView::Property::WIDGET_STATE_FAULTED; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_PERMANENT_DELETE_get() { + int jresult ; + int result; + + result = (int)Dali::WidgetView::WidgetView::Property::PERMANENT_DELETE; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_RETRY_TEXT_get() { + int jresult ; + int result; + + result = (int)Dali::WidgetView::WidgetView::Property::RETRY_TEXT; + jresult = (int)result; + return jresult; +} + +SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WidgetView_Property_EFFECT_get() { + int jresult ; + int result; + + result = (int)Dali::WidgetView::WidgetView::Property::EFFECT; + jresult = (int)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetView_Property() { + void * jresult ; + Dali::WidgetView::WidgetView::Property *result = 0 ; + + { + try { + result = (Dali::WidgetView::WidgetView::Property *)new Dali::WidgetView::WidgetView::Property(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetView_Property(void * jarg1) { + Dali::WidgetView::WidgetView::Property *arg1 = (Dali::WidgetView::WidgetView::Property *) 0 ; + + arg1 = (Dali::WidgetView::WidgetView::Property *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetView_New(char * jarg1, char * jarg2, int jarg3, int jarg4, float jarg5) { + void * jresult ; + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + int arg3 ; + int arg4 ; + float arg5 ; + Dali::WidgetView::WidgetView result; + + if (!jarg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg1_str(jarg1); + arg1 = &arg1_str; + if (!jarg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return 0; + } + std::string arg2_str(jarg2); + arg2 = &arg2_str; + arg3 = (int)jarg3; + arg4 = (int)jarg4; + arg5 = (float)jarg5; + { + try { + result = Dali::WidgetView::WidgetView::New((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::WidgetView::WidgetView((const Dali::WidgetView::WidgetView &)result); + + //argout typemap for const std::string& + + + //argout typemap for const std::string& + + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetView_DownCast(void * jarg1) { + void * jresult ; + Dali::BaseHandle arg1 ; + Dali::BaseHandle *argp1 ; + Dali::WidgetView::WidgetView 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::WidgetView::WidgetView::DownCast(arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = new Dali::WidgetView::WidgetView((const Dali::WidgetView::WidgetView &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetView__SWIG_0() { + void * jresult ; + Dali::WidgetView::WidgetView *result = 0 ; + + { + try { + result = (Dali::WidgetView::WidgetView *)new Dali::WidgetView::WidgetView(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetView__SWIG_1(void * jarg1) { + void * jresult ; + Dali::WidgetView::WidgetView *arg1 = 0 ; + Dali::WidgetView::WidgetView *result = 0 ; + + arg1 = (Dali::WidgetView::WidgetView *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetView::WidgetView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::WidgetView::WidgetView *)new Dali::WidgetView::WidgetView((Dali::WidgetView::WidgetView const &)*arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetView_Assign(void * jarg1, void * jarg2) { + void * jresult ; + Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; + Dali::WidgetView::WidgetView *arg2 = 0 ; + Dali::WidgetView::WidgetView *result = 0 ; + + arg1 = (Dali::WidgetView::WidgetView *)jarg1; + arg2 = (Dali::WidgetView::WidgetView *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetView::WidgetView const & type is null", 0); + return 0; + } + { + try { + result = (Dali::WidgetView::WidgetView *) &(arg1)->operator =((Dali::WidgetView::WidgetView const &)*arg2); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetView(void * jarg1) { + Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; + + arg1 = (Dali::WidgetView::WidgetView *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WidgetView_PauseWidget(void * jarg1) { + unsigned int jresult ; + Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; + bool result; + + arg1 = (Dali::WidgetView::WidgetView *)jarg1; + { + try { + result = (bool)(arg1)->PauseWidget(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WidgetView_ResumeWidget(void * jarg1) { + unsigned int jresult ; + Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; + bool result; + + arg1 = (Dali::WidgetView::WidgetView *)jarg1; + { + try { + result = (bool)(arg1)->ResumeWidget(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WidgetView_CancelTouchEvent(void * jarg1) { + unsigned int jresult ; + Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; + bool result; + + arg1 = (Dali::WidgetView::WidgetView *)jarg1; + { + try { + result = (bool)(arg1)->CancelTouchEvent(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetView_ActivateFaultedWidget(void * jarg1) { + Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; + + arg1 = (Dali::WidgetView::WidgetView *)jarg1; + { + try { + (arg1)->ActivateFaultedWidget(); + } CALL_CATCH_EXCEPTION(); + } +} + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WidgetView_TerminateWidget(void * jarg1) { + unsigned int jresult; + Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; + bool result; + + arg1 = (Dali::WidgetView::WidgetView *)jarg1; + { + try { + result = (bool)(arg1)->TerminateWidget(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetView_WidgetAddedSignal(void * jarg1) { + void * jresult ; + Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; + Dali::WidgetView::WidgetView::WidgetViewSignalType *result = 0 ; + + arg1 = (Dali::WidgetView::WidgetView *)jarg1; + { + try { + result = (Dali::WidgetView::WidgetView::WidgetViewSignalType *) &(arg1)->WidgetAddedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetView_WidgetDeletedSignal(void * jarg1) { + void * jresult ; + Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; + Dali::WidgetView::WidgetView::WidgetViewSignalType *result = 0 ; + + arg1 = (Dali::WidgetView::WidgetView *)jarg1; + { + try { + result = (Dali::WidgetView::WidgetView::WidgetViewSignalType *) &(arg1)->WidgetDeletedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetView_WidgetCreationAbortedSignal(void * jarg1) { + void * jresult ; + Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; + Dali::WidgetView::WidgetView::WidgetViewSignalType *result = 0 ; + + arg1 = (Dali::WidgetView::WidgetView *)jarg1; + { + try { + result = (Dali::WidgetView::WidgetView::WidgetViewSignalType *) &(arg1)->WidgetCreationAbortedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetView_WidgetContentUpdatedSignal(void * jarg1) { + void * jresult ; + Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; + Dali::WidgetView::WidgetView::WidgetViewSignalType *result = 0 ; + + arg1 = (Dali::WidgetView::WidgetView *)jarg1; + { + try { + result = (Dali::WidgetView::WidgetView::WidgetViewSignalType *) &(arg1)->WidgetContentUpdatedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetView_WidgetUpdatePeriodChangedSignal(void * jarg1) { + void * jresult ; + Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; + Dali::WidgetView::WidgetView::WidgetViewSignalType *result = 0 ; + + arg1 = (Dali::WidgetView::WidgetView *)jarg1; + { + try { + result = (Dali::WidgetView::WidgetView::WidgetViewSignalType *) &(arg1)->WidgetUpdatePeriodChangedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetView_WidgetFaultedSignal(void * jarg1) { + void * jresult ; + Dali::WidgetView::WidgetView *arg1 = (Dali::WidgetView::WidgetView *) 0 ; + Dali::WidgetView::WidgetView::WidgetViewSignalType *result = 0 ; + + arg1 = (Dali::WidgetView::WidgetView *)jarg1; + { + try { + result = (Dali::WidgetView::WidgetView::WidgetViewSignalType *) &(arg1)->WidgetFaultedSignal(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + + +//For widget view signal +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WidgetViewSignal_Empty(void * jarg1) { + unsigned int jresult ; + Dali::Signal< void (Dali::WidgetView::WidgetView) > *arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *) 0 ; + bool result; + + arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *)jarg1; + { + try { + result = (bool)Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__Empty((Dali::Signal< void (Dali::WidgetView::WidgetView) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WidgetViewSignal_GetConnectionCount(void * jarg1) { + unsigned long jresult ; + Dali::Signal< void (Dali::WidgetView::WidgetView) > *arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *) 0 ; + std::size_t result; + + arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *)jarg1; + { + try { + result = Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WidgetView::WidgetView) > const *)arg1); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetViewSignal_Connect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::WidgetView::WidgetView) > *arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *) 0 ; + void (*arg2)(Dali::WidgetView::WidgetView) = (void (*)(Dali::WidgetView::WidgetView)) 0 ; + + arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *)jarg1; + arg2 = (void (*)(Dali::WidgetView::WidgetView))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__Connect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetViewSignal_Disconnect(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::WidgetView::WidgetView) > *arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *) 0 ; + void (*arg2)(Dali::WidgetView::WidgetView) = (void (*)(Dali::WidgetView::WidgetView)) 0 ; + + arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *)jarg1; + arg2 = (void (*)(Dali::WidgetView::WidgetView))jarg2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__Disconnect(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetViewSignal_Emit(void * jarg1, void * jarg2) { + Dali::Signal< void (Dali::WidgetView::WidgetView) > *arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *) 0 ; + Dali::WidgetView::WidgetView arg2 ; + Dali::WidgetView::WidgetView *argp2 ; + + arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *)jarg1; + argp2 = (Dali::WidgetView::WidgetView *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::WidgetView::WidgetView", 0); + return ; + } + arg2 = *argp2; + { + try { + Dali_Signal_Sl_void_Sp_Dali_WidgetView_WidgetView_SP__Sg__Emit(arg1,arg2); + } CALL_CATCH_EXCEPTION(); + } + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetViewSignal() { + void * jresult ; + Dali::Signal< void (Dali::WidgetView::WidgetView) > *result = 0 ; + + { + try { + result = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *)new Dali::Signal< void (Dali::WidgetView::WidgetView) >(); + } CALL_CATCH_EXCEPTION(0); + } + + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetViewSignal(void * jarg1) { + Dali::Signal< void (Dali::WidgetView::WidgetView) > *arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *) 0 ; + + arg1 = (Dali::Signal< void (Dali::WidgetView::WidgetView) > *)jarg1; + { + try { + delete arg1; + } CALL_CATCH_EXCEPTION(); + } + +} + +#ifdef __cplusplus +} +#endif +